# Samsung Galaxy Store Apps Scraper (`automation-lab/samsung-galaxy-store-apps-scraper`) Actor

📱 Extract localized Galaxy Store titles, descriptions, IDs, icons, developer links, locale alternates, deep links, and availability from known apps.

- **URL**: https://apify.com/automation-lab/samsung-galaxy-store-apps-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Samsung Galaxy Store Apps Scraper

Extract localized public Samsung Galaxy Store app metadata from package IDs or detail URLs.
Get clean titles, descriptions, identifiers, icons, developer links, canonical URLs, locale alternates,
Android deep links, and availability status without maintaining a custom parser.

Use the Actor for ASO research, app-catalog enrichment, localization audits, and recurring competitor checks.
It accepts up to 100 known apps per run and exports one structured dataset row per app and requested locale.

> This V1 focuses on reliable known-app enrichment. It does not claim Galaxy Store search, category crawling,
> rankings, download counts, ratings, or reviews.

### What does Samsung Galaxy Store Apps Scraper do?

The Actor turns public Galaxy Store detail pages into structured records.

- 📱 Accept package IDs such as `com.samsung.android.app.spage`.
- 🔗 Accept `galaxystore.samsung.com/detail/...` URLs.
- 🌍 Request a language and country combination.
- 🧭 Discover canonical and hreflang alternate URLs.
- ✅ Distinguish available, fallback, and not-found results.
- 📦 Export JSON, CSV, Excel, XML, RSS, or JSONL through Apify datasets.

It uses server-rendered public metadata, so it does not need a browser, login, seller account, or API key.

### Who is it for?

#### ASO and localization teams

Audit how known Samsung apps appear across markets and identify missing localizations.
Track title or description changes in scheduled runs.

#### App-intelligence teams

Enrich a catalog of package IDs with Galaxy Store identifiers, icons, developer URLs, and deep links.
Join the results with Google Play or Apple App Store datasets downstream.

#### Developers and data engineers

Replace fragile HTML parsing with an Actor API, webhook, schedule, or integration.
Receive predictable typed records even when an app is unavailable.

#### Agencies and analysts

Monitor a fixed competitor list and deliver repeatable market snapshots to clients.

### Why use this Galaxy Store extractor?

- **Source-specific fields:** retain Samsung package, store, locale, and deep-link semantics.
- **Localized requests:** control both language and three-letter country code.
- **Explicit fallback:** fallback records never falsely claim requested-market availability.
- **Safe URL scope:** URL inputs must point to a Galaxy Store app detail page.
- **Batch workflow:** process up to 100 unique known apps per run.
- **Automation-ready:** connect datasets to APIs, webhooks, schedules, or cloud storage.
- **No authentication:** extract only anonymous public metadata.

### What data can you extract?

| Field | Meaning |
|---|---|
| `title` | Localized public app title |
| `description` | Localized public app description |
| `developerUrl` | Developer website exposed by Galaxy Store |
| `packageId` | Normalized Android-style package identifier |
| `storeId` | Galaxy Store identifier |
| `iconUrl` | Public app icon URL |
| `canonicalUrl` | Canonical Galaxy Store detail URL |
| `localeAlternates` | `hreflang|URL` strings for available alternate pages |
| `androidDeepLink` | `samsungapps://` product detail deep link |
| `status` | `available`, `fallback`, or `not_found` |
| `isAvailableInRequestedLocale` | Whether the requested locale returned app metadata |
| `requestedLocale` | Requested language and country combination |
| `resolvedLocale` | Locale used for returned metadata |
| `sourceUrl` | Original normalized requested URL |
| `fetchedUrl` | URL that produced the final result |
| `scrapedAt` | ISO timestamp of extraction |

### How to scrape Samsung Galaxy Store apps

1. Open the Actor input page.
2. Add one or more package IDs or Galaxy Store detail URLs.
3. Choose a language code such as `en_US` or `de_DE`.
4. Choose a three-letter country code such as `USA` or `DEU`.
5. Keep fallback enabled if US English metadata is useful when a locale is unavailable.
6. Click **Start**.
7. Open the dataset to preview or download the app records.

The default input uses one deterministic Samsung package so a first run stays quick and inexpensive.

### Input parameters

#### Galaxy Store package IDs

`packageIds` accepts up to 100 IDs. Package IDs must contain dot-separated letters, numbers, or underscores.
Duplicates across IDs and URLs are removed before requests begin.

#### Galaxy Store detail URLs

`startUrls` accepts public URLs in this exact scope:

```text
https://galaxystore.samsung.com/detail/com.samsung.android.app.spage
````

URLs from other hosts, catalog pages, or unrelated paths fail validation instead of silently changing product scope.

#### Localization

`languageCode` accepts forms such as `en`, `en_US`, `ko_KR`, and `de_DE`.
`countryCode` uses Samsung's three-letter country values, for example `USA`, `GBR`, `KOR`, and `DEU`.

#### Fallback behavior

When `fallbackToDefaultLocale` is true and the requested page does not expose valid app metadata,
the Actor tries one bounded `en_US` / `USA` request.
A successful fallback has `status: "fallback"` and `isAvailableInRequestedLocale: false`.

### Example input: package IDs

```json
{
  "packageIds": [
    "com.samsung.android.app.spage",
    "com.samsung.android.game.gamehome"
  ],
  "languageCode": "en_US",
  "countryCode": "USA",
  "fallbackToDefaultLocale": true
}
```

### Example input: detail URLs

```json
{
  "startUrls": [
    {
      "url": "https://galaxystore.samsung.com/detail/com.android.samsung.utilityapp"
    }
  ],
  "languageCode": "de_DE",
  "countryCode": "DEU"
}
```

You may combine `packageIds` and `startUrls` in the same run.

### Example output

```json
{
  "title": "Samsung News",
  "description": "Get news from every angle...",
  "developerUrl": "https://www.samsung.com",
  "packageId": "com.samsung.android.app.spage",
  "storeId": "com.samsung.android.app.spage",
  "iconUrl": "https://img.samsungapps.com/productNew/...png",
  "canonicalUrl": "https://galaxystore.samsung.com/detail/com.samsung.android.app.spage",
  "androidDeepLink": "samsungapps://ProductDetail/com.samsung.android.app.spage?gsw_source=GSWebToDetail",
  "isAvailableInRequestedLocale": true,
  "status": "available",
  "requestedLanguageCode": "en_US",
  "requestedCountryCode": "USA",
  "requestedLocale": "en_US_USA",
  "resolvedLocale": "en_US_USA",
  "sourceUrl": "https://galaxystore.samsung.com/detail/com.samsung.android.app.spage?langCd=en_US&cntyCd=USA",
  "scrapedAt": "2026-07-18T00:00:00.000Z"
}
```

Optional metadata is omitted when Samsung does not expose it. Core status and request fields remain present.

### How much does it cost to scrape Galaxy Store app metadata?

This Actor uses pay-per-event pricing:

- **Start:** a small one-time charge for each run.
- **App record:** one charge for each dataset row, including explicit not-found records.
- **Volume discounts:** lower per-record prices on higher Apify subscription tiers.

Current rates are a $0.005 start plus the following price per app record:

| Apify tier | Price per app record |
|---|---:|
| Free | $0.00022105 |
| Bronze | $0.00019222 |
| Silver | $0.00014993 |
| Gold | $0.00011533 |
| Platinum | $0.000076888 |
| Diamond | $0.000053821 |

Keep known apps together in one batch to avoid repeated start fees.
A one-app smoke test is the cheapest way to validate your workflow before scheduling a larger catalog.

### Localization and availability semantics

`available` means Samsung returned valid app metadata for the requested language and country URL.
`fallback` means that URL did not provide valid metadata, but US English did.
`not_found` means neither the requested URL nor the enabled bounded fallback returned a matching app record.

The Actor validates Samsung's returned bundle ID against your requested package.
A generic Galaxy Store error page is never emitted as a real app.

### Tips for reliable app catalog audits

- 🧪 Begin with one package and the default locale.
- 🗺️ Use three-letter country codes, not two-letter codes.
- 🔁 Schedule identical inputs to detect metadata or availability changes.
- 🧩 Keep package IDs as your stable join key across app stores.
- 📊 Compare `status` and `resolvedLocale`, not title alone.
- 🛑 Disable fallback when you need strict requested-market availability only.
- 🐛 Enable `debug` only when troubleshooting because it saves raw HTML to the key-value store.

### Integrations and automation workflows

#### Google Sheets and Excel

Schedule a package list, export the dataset as CSV or Excel, and compare localized columns between runs.

#### Webhooks and change alerts

Attach a run-finished webhook, fetch the dataset, and notify Slack or email when a package changes to `not_found`.

#### Data warehouses

Load JSONL into BigQuery, Snowflake, or a lakehouse and join by `packageId` and `requestedLocale`.

#### Multi-store app intelligence

Combine this Actor with Google Play and Apple App Store data in your own pipeline.
Keep source-specific status fields while normalizing shared fields such as title, description, developer, and icon.

### Use the Actor through the API

Replace `<APIFY_TOKEN>` with your Apify API token.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/samsung-galaxy-store-apps-scraper').call({
  packageIds: ['com.samsung.android.app.spage'],
  languageCode: 'en_US',
  countryCode: 'USA',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('<APIFY_TOKEN>')
run = client.actor('automation-lab/samsung-galaxy-store-apps-scraper').call(run_input={
    'packageIds': ['com.samsung.android.app.spage'],
    'languageCode': 'en_US',
    'countryCode': 'USA',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~samsung-galaxy-store-apps-scraper/runs?token=<APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"packageIds":["com.samsung.android.app.spage"],"languageCode":"en_US","countryCode":"USA"}'
```

### Use with Apify MCP and AI assistants

Connect the Actor to Claude Code:

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

For Claude Desktop, Cursor, or VS Code, add this MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/samsung-galaxy-store-apps-scraper"
    }
  }
}
```

Example prompts:

- “Extract US English metadata for these five Galaxy Store package IDs.”
- “Check whether these Samsung apps are available in Germany and return fallback status.”
- “Compare this week's Galaxy Store titles with my previous dataset.”

### Scheduling a Galaxy Store monitor

Create an Apify schedule with your stable competitor package list.
Send each completed dataset to your preferred integration or webhook.
Store historical snapshots using the run ID and `scrapedAt` timestamp.

For strict regional checks, disable fallback and alert on `not_found`.
For catalog enrichment, leave fallback enabled so your pipeline can still receive useful public metadata.

### Error handling

Invalid package IDs and out-of-scope URLs fail fast with a clear message.
Transient server or rate-limit failures use bounded retries.
One failed request does not erase valid rows from other package IDs.
If every app request fails at the transport or extraction layer, the run fails instead of reporting a false success.

A valid missing package is different: it produces a typed `not_found` row for downstream monitoring.

### Is it legal to scrape Galaxy Store metadata?

The Actor extracts publicly accessible app metadata and does not bypass login or access private user data.
You are responsible for your use case, request volume, contracts, and compliance with applicable laws and Samsung's terms.
Do not use the output for spam, impersonation, or infringement.
Avoid submitting personal data as input.

### FAQ

#### Does this Actor search the whole Galaxy Store?

No. V1 enriches known package IDs and detail URLs. It does not promise unproven search, rankings, categories, or reviews.

#### Does it require a Samsung account or proxy?

No. The supported detail metadata is publicly available through anonymous HTTP responses.

#### Why did I get `status: "fallback"`?

The requested locale did not expose matching app metadata, while the bounded US English fallback did.
Check `isAvailableInRequestedLocale` and `resolvedLocale` before using localized text.

#### Why did I get `not_found` for a real app?

The package may not be published in the requested country, may have moved, or may no longer be public.
Try the default `en_US` / `USA` combination and confirm the package ID from a current Galaxy Store detail URL.

#### Can I submit Google Play URLs?

No. URL scope is enforced. Extract the package ID and submit it directly, or use a dedicated Google Play actor.

#### How many apps can one run process?

Up to 100 unique package IDs after deduplication.
Use multiple scheduled runs for larger catalogs.

### Related scrapers

Build a broader app-intelligence workflow with other automation-lab Actors:

- [Google Play Store Scraper](https://apify.com/automation-lab/google-play-scraper)
- [Apple App Store Scraper](https://apify.com/automation-lab/apple-app-store-scraper)

Use this Actor when Samsung Galaxy Store locale and availability semantics matter.
Use source-specific companion Actors for other stores rather than treating them as equivalent.

### Support

If a current public Galaxy Store detail page produces an incorrect record, open an Actor issue with:

- the package ID or source URL,
- requested language and country,
- expected status or field,
- run ID,
- and a small output sample.

Do not include passwords, tokens, private account information, or unrelated personal data.

# Actor input Schema

## `packageIds` (type: `array`):

Enter up to 100 Android-style package IDs, for example com.samsung.android.app.spage.

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

Optionally add galaxystore.samsung.com/detail/... URLs. Other hosts and paths are rejected.

## `languageCode` (type: `string`):

Use a two-letter language or locale code, such as en, en\_US, ko\_KR, or de\_DE.

## `countryCode` (type: `string`):

Use a three-letter country code such as USA, GBR, DEU, or KOR.

## `fallbackToDefaultLocale` (type: `boolean`):

When the requested locale is unavailable, try en\_US / USA and mark the row with status fallback.

## `debug` (type: `boolean`):

Save raw source HTML in the key-value store for troubleshooting. Leave disabled for normal runs.

## Actor input object example

```json
{
  "packageIds": [
    "com.samsung.android.app.spage"
  ],
  "startUrls": [],
  "languageCode": "en_US",
  "countryCode": "USA",
  "fallbackToDefaultLocale": true,
  "debug": false
}
```

# 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 = {
    "packageIds": [
        "com.samsung.android.app.spage"
    ],
    "startUrls": [],
    "languageCode": "en_US",
    "countryCode": "USA",
    "fallbackToDefaultLocale": true,
    "debug": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/samsung-galaxy-store-apps-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 = {
    "packageIds": ["com.samsung.android.app.spage"],
    "startUrls": [],
    "languageCode": "en_US",
    "countryCode": "USA",
    "fallbackToDefaultLocale": True,
    "debug": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/samsung-galaxy-store-apps-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 '{
  "packageIds": [
    "com.samsung.android.app.spage"
  ],
  "startUrls": [],
  "languageCode": "en_US",
  "countryCode": "USA",
  "fallbackToDefaultLocale": true,
  "debug": false
}' |
apify call automation-lab/samsung-galaxy-store-apps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Samsung Galaxy Store Apps Scraper",
        "description": "📱 Extract localized Galaxy Store titles, descriptions, IDs, icons, developer links, locale alternates, deep links, and availability from known apps.",
        "version": "0.1",
        "x-build-id": "ZIRQgJKwOl8cqisWM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~samsung-galaxy-store-apps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-samsung-galaxy-store-apps-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~samsung-galaxy-store-apps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-samsung-galaxy-store-apps-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~samsung-galaxy-store-apps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-samsung-galaxy-store-apps-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": {
                    "packageIds": {
                        "title": "Galaxy Store package IDs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Enter up to 100 Android-style package IDs, for example com.samsung.android.app.spage.",
                        "default": [
                            "com.samsung.android.app.spage"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Galaxy Store detail URLs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Optionally add galaxystore.samsung.com/detail/... URLs. Other hosts and paths are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "languageCode": {
                        "title": "Language code",
                        "pattern": "^[a-z]{2}([_-][A-Z]{2})?$",
                        "type": "string",
                        "description": "Use a two-letter language or locale code, such as en, en_US, ko_KR, or de_DE.",
                        "default": "en_US"
                    },
                    "countryCode": {
                        "title": "Country code",
                        "pattern": "^[A-Za-z]{3}$",
                        "type": "string",
                        "description": "Use a three-letter country code such as USA, GBR, DEU, or KOR.",
                        "default": "USA"
                    },
                    "fallbackToDefaultLocale": {
                        "title": "Fall back to US English",
                        "type": "boolean",
                        "description": "When the requested locale is unavailable, try en_US / USA and mark the row with status fallback.",
                        "default": true
                    },
                    "debug": {
                        "title": "Save response HTML",
                        "type": "boolean",
                        "description": "Save raw source HTML in the key-value store for troubleshooting. Leave disabled for normal runs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```