# Epic Games Store Scraper (`logiover/epic-games-store-scraper`) Actor

Scrape Epic Games Store listings: title, price, discount, developer, genres, ratings, images and free game promotions. Search by keyword, browse by category or scrape current/upcoming free games. No API key needed.

- **URL**: https://apify.com/logiover/epic-games-store-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## 🎮 Epic Games Store Scraper

Scrape game listings, prices, discounts, promotions and free games from the [Epic Games Store](https://store.epicgames.com) — **no API key, no authentication required**.

The scraper uses two techniques depending on the mode:
- **Free games** → direct public REST endpoint, instant, zero overhead
- **Search / Browse / Product URLs** → headless Chromium intercepts Epic's own GraphQL responses as the page loads, bypassing all server-side bot protection naturally

---

### 📦 What you get

| Field | Description | Example |
|-------|-------------|---------|
| `title` | Game title | `"Celeste"` |
| `seller` | Store seller name | `"Maddy Makes Games"` |
| `developer` | Developer | `"Maddy Makes Games"` |
| `publisher` | Publisher | `"Maddy Makes Games"` |
| `priceOriginal` | Original formatted price | `"$19.99"` |
| `priceDiscounted` | Current sale price | `"$9.99"` |
| `discountPercent` | Discount % | `50` |
| `isFree` | Permanently free to play | `false` |
| `isOnSale` | Currently discounted | `true` |
| `currency` | Currency code | `"USD"` |
| `releaseDate` | Release date (ISO 8601) | `"2018-01-25T00:00:00.000Z"` |
| `isCurrentlyFree` | Active free promotion | `false` |
| `isUpcomingFree` | Scheduled free promotion | `true` |
| `promotionStartDate` | Promo start (ISO 8601) | `"2026-04-10T15:00:00.000Z"` |
| `promotionEndDate` | Promo end (ISO 8601) | `"2026-04-17T15:00:00.000Z"` |
| `categories` | Category paths | `["games", "games/edition/base"]` |
| `tags` | Genre/feature tags | `["Platformer", "Indie", "Single Player"]` |
| `imageWide` | Wide banner image URL | `"https://cdn1.epicgames.com/..."` |
| `imageTall` | Tall portrait cover URL | `"https://cdn1.epicgames.com/..."` |
| `storeUrl` | Full store page URL | `"https://store.epicgames.com/en-US/p/celeste"` |

---

### 🚀 Modes

#### 🎁 Free Games (recommended starting point)
Fetches all current and upcoming free game promotions. Epic gives away games every week. This mode uses a direct public REST endpoint — no browser, runs in seconds.

```json
{
  "mode": "free_games",
  "country": "US",
  "locale": "en-US"
}
````

**Output fields specific to this mode:**

- `isCurrentlyFree: true` — game is free right now, grab it before `promotionEndDate`
- `isUpcomingFree: true` — game will be free from `promotionStartDate`

***

#### 🔍 Keyword Search

Find games matching one or more keywords. Each keyword runs as a separate search. Uses a headless browser to load the store page and capture the API response.

```json
{
  "mode": "search",
  "searchQueries": ["cyberpunk", "souls-like", "city builder"],
  "country": "US",
  "maxResults": 50
}
```

***

#### 📋 Browse Catalog

Paginate through Epic's full game catalog with optional filters.

```json
{
  "mode": "browse",
  "category": "Game",
  "sortBy": "releaseDate",
  "sortDir": "DESC",
  "country": "US",
  "maxResults": 200
}
```

**Browse on sale only:**

```json
{
  "mode": "browse",
  "onSaleOnly": true,
  "sortBy": "currentPrice",
  "sortDir": "ASC",
  "country": "US",
  "maxResults": 100
}
```

***

#### 🔗 Specific Product URLs

Scrape exact product pages you provide.

```json
{
  "mode": "product_urls",
  "startUrls": [
    { "url": "https://store.epicgames.com/en-US/p/celeste" },
    { "url": "https://store.epicgames.com/en-US/p/hades" },
    { "url": "https://store.epicgames.com/en-US/p/disco-elysium-the-final-cut" }
  ],
  "country": "US"
}
```

***

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `free_games` | `free_games`, `search`, `browse`, `product_urls` |
| `searchQueries` | array | `[]` | Keywords for search mode |
| `startUrls` | array | `[]` | Product page URLs for product\_urls mode |
| `category` | string | `Game` | Category filter for browse mode |
| `sortBy` | string | `releaseDate` | `releaseDate`, `title`, `currentPrice`, `upcoming` |
| `sortDir` | string | `DESC` | `DESC` or `ASC` |
| `onSaleOnly` | boolean | `false` | Return only discounted games |
| `country` | string | `US` | ISO country code for pricing |
| `locale` | string | `en-US` | Language locale |
| `maxResults` | integer | `100` | Max results total (0 = unlimited) |
| `proxyConfiguration` | object | disabled | Optional proxy (not required for standard use) |

***

### 💡 Use cases

**Weekly free game alerts** — Schedule `free_games` mode to run daily. When `isCurrentlyFree` or `isUpcomingFree` changes, trigger a notification via webhook to Slack, Discord, or email.

**Price intelligence across regions** — Run with different `country` codes (`US`, `TR`, `AR`, `BR`, `DE`) to compare regional pricing. Epic's prices vary dramatically by region — Argentina and Turkey are commonly cheaper.

**Sale tracking** — Set `onSaleOnly: true` in browse mode and schedule weekly runs. Export to Google Sheets to track discount history over time.

**Game catalog database** — Run browse mode with `maxResults: 0` to export Epic's entire catalog. Combine with Steam scraper data for cross-platform market analysis.

**Competitor analysis** — Search for specific publishers by name and monitor their catalog, pricing strategy, and promotions.

**Deal newsletters** — Combine free games + on-sale results and pipe the output to a newsletter automation via Make.com or Zapier.

***

### 📊 Sample output

```json
{
  "title": "Celeste",
  "id": "b671fbc7be424e888c9346a9a6d3d9db",
  "seller": "Maddy Makes Games",
  "developer": "Maddy Makes Games",
  "publisher": "Maddy Makes Games",
  "priceOriginal": "$19.99",
  "priceDiscounted": "$19.99",
  "priceOriginalRaw": 1999,
  "discountPercent": 0,
  "isFree": false,
  "isOnSale": false,
  "currency": "USD",
  "releaseDate": "2018-01-25T05:00:00.000Z",
  "isCurrentlyFree": false,
  "isUpcomingFree": false,
  "categories": ["games", "games/edition/base", "applications"],
  "tags": ["Platformer", "Difficult", "Single Player", "Indie"],
  "imageWide": "https://cdn1.epicgames.com/b671fbc7be424e888c9346a9a6d3d9db/offer/Celeste-2560x1440.jpg",
  "storeUrl": "https://store.epicgames.com/en-US/p/celeste",
  "country": "US",
  "scrapedAt": "2026-04-05T12:00:00.000Z"
}
```

**Free game example:**

```json
{
  "title": "Havendock",
  "priceOriginal": "$19.99",
  "priceDiscounted": "0",
  "discountPercent": 100,
  "isFree": false,
  "isCurrentlyFree": true,
  "isUpcomingFree": false,
  "promotionStartDate": "2026-03-26T15:00:00.000Z",
  "promotionEndDate": "2026-04-02T15:00:00.000Z",
  "storeUrl": "https://store.epicgames.com/en-US/p/havendock-64983e"
}
```

***

### ⚡ Performance & cost

| Mode | Method | Speed | Cost estimate |
|------|--------|-------|---------------|
| `free_games` | REST (no browser) | ~1 second | Minimal |
| `search` | Headless browser | ~5s per keyword | Low |
| `browse` | Headless browser | ~5s per 40 results | Low |
| `product_urls` | Headless browser | ~5s per URL | Low |

The headless browser approach is more resource-intensive than pure HTTP scraping but is the only reliable method that bypasses Epic's server-side API protection without requiring a paid proxy.

***

### 🔧 Technical notes

- **Free games mode** uses `store-site-backend-static-ipv4.ak.epicgames.com/freeGamesPromotions` — a stable public CDN endpoint used by many open-source projects
- **Browser modes** launch headless Chromium via Playwright, navigate to the Epic Store browse page, and intercept the GraphQL API response that the page itself fetches — no bot detection because it's a real browser making real requests
- Heavy resources (images, fonts, analytics, tracking) are blocked during browser sessions to reduce memory usage and speed up scraping
- A 1.5 second delay between pages is applied to avoid overwhelming Epic's servers
- **Proxy is optional** — the browser-based approach works without proxy for standard use. Enable Apify Residential Proxy only if you're running very large batch scrapes that trigger rate limits.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. 'free\_games' fetches current and upcoming free game promotions via the public REST endpoint — fastest, no browser needed. 'search' finds games by keyword using a headless browser. 'browse' paginates through the full catalog. 'product\_urls' scrapes specific Epic Store product page URLs.

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

Keywords to search for on the Epic Games Store. Used when mode is 'search'. Each keyword runs as a separate search. Examples: 'cyberpunk', 'horror', 'open world RPG', 'battle royale'.

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

Epic Games Store product page URLs to scrape. Used when mode is 'product\_urls'. Paste the full URL from the store page. Example: https://store.epicgames.com/en-US/p/celeste

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

Filter by store category. Used in 'browse' mode. Common values: 'Game' (all games), 'Game/Edition/Base' (base editions, excludes DLC/bundles). Leave empty to include everything.

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

How to sort results in browse and search modes.

## `sortDir` (type: `string`):

Sort direction: DESC = newest/highest first, ASC = oldest/lowest first.

## `onSaleOnly` (type: `boolean`):

When enabled, only return games currently on sale with an active discount.

## `country` (type: `string`):

Two-letter ISO country code for pricing and availability. Determines the currency shown in results. Common values: US (USD), GB (GBP), DE (EUR), TR (TRY), BR (BRL), AR (ARS), JP (JPY).

## `locale` (type: `string`):

Language locale for titles and descriptions. Examples: en-US (English), de (German), fr (French), tr (Turkish), pt-BR (Portuguese).

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

Maximum number of game listings to return. Set to 0 for unlimited — the scraper will paginate automatically. In 'search' mode each query counts separately.

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

Optional proxy settings for the headless browser (search, browse, product\_urls modes). Leave at default for most use cases — the browser-based approach works without proxy for standard runs. Enable Apify Proxy if you encounter blocks on large-scale scrapes.

## Actor input object example

```json
{
  "mode": "free_games",
  "searchQueries": [],
  "startUrls": [
    {
      "url": "https://store.epicgames.com/en-US/p/celeste"
    }
  ],
  "category": "Game",
  "sortBy": "releaseDate",
  "sortDir": "DESC",
  "onSaleOnly": false,
  "country": "US",
  "locale": "en-US",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `title` (type: `string`):

Game title

## `id` (type: `string`):

Epic internal offer ID

## `namespace` (type: `string`):

Epic catalog namespace

## `description` (type: `string`):

Short game description

## `storeUrl` (type: `string`):

Full Epic Store URL

## `seller` (type: `string`):

Seller / publisher name on store

## `developer` (type: `string`):

Developer name

## `publisher` (type: `string`):

Publisher name

## `priceOriginal` (type: `string`):

Original formatted price

## `priceDiscounted` (type: `string`):

Discounted formatted price

## `priceOriginalRaw` (type: `string`):

Original price in smallest currency unit

## `discountPercent` (type: `string`):

Active discount percentage

## `isFree` (type: `string`):

Permanently free to play

## `isOnSale` (type: `string`):

Currently discounted

## `currency` (type: `string`):

Currency code (USD, EUR, etc.)

## `releaseDate` (type: `string`):

Release date (ISO 8601)

## `isCurrentlyFree` (type: `string`):

Active free game promotion

## `isUpcomingFree` (type: `string`):

Scheduled future free promotion

## `promotionStartDate` (type: `string`):

Promotion start date (ISO)

## `promotionEndDate` (type: `string`):

Promotion end date (ISO)

## `imageWide` (type: `string`):

1920x1080 landscape banner URL

## `imageTall` (type: `string`):

Portrait cover image URL

## `imageThumbnail` (type: `string`):

Thumbnail image URL

## `categories` (type: `string`):

Store category paths

## `tags` (type: `string`):

Genre and feature tag names

## `country` (type: `string`):

Country used for pricing

## `scrapedAt` (type: `string`):

ISO timestamp of the scrape

# 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": [
        {
            "url": "https://store.epicgames.com/en-US/p/celeste"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/epic-games-store-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": [{ "url": "https://store.epicgames.com/en-US/p/celeste" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/epic-games-store-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": [
    {
      "url": "https://store.epicgames.com/en-US/p/celeste"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call logiover/epic-games-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Epic Games Store Scraper",
        "description": "Scrape Epic Games Store listings: title, price, discount, developer, genres, ratings, images and free game promotions. Search by keyword, browse by category or scrape current/upcoming free games. No API key needed.",
        "version": "0.0",
        "x-build-id": "dYUHPhNuPgOKaeyvO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~epic-games-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-epic-games-store-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/logiover~epic-games-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-epic-games-store-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/logiover~epic-games-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-epic-games-store-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": {
                    "mode": {
                        "title": "Scrape Mode",
                        "enum": [
                            "free_games",
                            "search",
                            "browse",
                            "product_urls"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'free_games' fetches current and upcoming free game promotions via the public REST endpoint — fastest, no browser needed. 'search' finds games by keyword using a headless browser. 'browse' paginates through the full catalog. 'product_urls' scrapes specific Epic Store product page URLs.",
                        "default": "free_games"
                    },
                    "searchQueries": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for on the Epic Games Store. Used when mode is 'search'. Each keyword runs as a separate search. Examples: 'cyberpunk', 'horror', 'open world RPG', 'battle royale'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Epic Games Store product page URLs to scrape. Used when mode is 'product_urls'. Paste the full URL from the store page. Example: https://store.epicgames.com/en-US/p/celeste",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "category": {
                        "title": "Category Filter",
                        "type": "string",
                        "description": "Filter by store category. Used in 'browse' mode. Common values: 'Game' (all games), 'Game/Edition/Base' (base editions, excludes DLC/bundles). Leave empty to include everything.",
                        "default": "Game"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "releaseDate",
                            "title",
                            "currentPrice",
                            "upcoming"
                        ],
                        "type": "string",
                        "description": "How to sort results in browse and search modes.",
                        "default": "releaseDate"
                    },
                    "sortDir": {
                        "title": "Sort Direction",
                        "enum": [
                            "DESC",
                            "ASC"
                        ],
                        "type": "string",
                        "description": "Sort direction: DESC = newest/highest first, ASC = oldest/lowest first.",
                        "default": "DESC"
                    },
                    "onSaleOnly": {
                        "title": "On Sale Only",
                        "type": "boolean",
                        "description": "When enabled, only return games currently on sale with an active discount.",
                        "default": false
                    },
                    "country": {
                        "title": "Country Code",
                        "type": "string",
                        "description": "Two-letter ISO country code for pricing and availability. Determines the currency shown in results. Common values: US (USD), GB (GBP), DE (EUR), TR (TRY), BR (BRL), AR (ARS), JP (JPY).",
                        "default": "US"
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Language locale for titles and descriptions. Examples: en-US (English), de (German), fr (French), tr (Turkish), pt-BR (Portuguese).",
                        "default": "en-US"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of game listings to return. Set to 0 for unlimited — the scraper will paginate automatically. In 'search' mode each query counts separately.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings for the headless browser (search, browse, product_urls modes). Leave at default for most use cases — the browser-based approach works without proxy for standard runs. Enable Apify Proxy if you encounter blocks on large-scale scrapes."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
