# Gianttiger Product Search Scraper (`stealth_mode/gianttiger-product-search-scraper`) Actor

Scrape product details from Giant Tiger's collection pages with precision. This scraper extracts 41+ fields including pricing, inventory levels, variants, SKUs, and product metadata — perfect for ecommerce analysts, resellers, and market researchers.

- **URL**: https://apify.com/stealth\_mode/gianttiger-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Giant Tiger Product Search Scraper: Extract Retail Inventory Data Fast

---

### What Is Giant Tiger?

Giant Tiger is a major Canadian discount retail chain operating hundreds of locations across Canada. Their online store features diverse product categories, from apparel to home goods, with real-time inventory management across brick-and-mortar and online channels. Collecting product intelligence from Giant Tiger's collections manually is tedious and error-prone — the **Giant Tiger Product Search Scraper** automates the extraction of rich product data from search results and category pages.

---

### Overview

The **Giant Tiger Product Search Scraper** extracts comprehensive product records from Giant Tiger's collection pages, converting search results into structured datasets. It is designed for:

- **Ecommerce analysts** monitoring competitor pricing and inventory
- **Market researchers** studying retail product availability and trends
- **Resellers** tracking SKUs and pricing across different product categories
- **Data engineers** building retail intelligence pipelines
- **Developers** aggregating Giant Tiger product data into custom applications

The scraper excels at handling pagination, filtering (by store inventory and online availability), and collecting up to 200 products per URL with graceful failure handling.

---

### Input Format

The scraper accepts a JSON configuration object:

```json
{
  "urls": [
    "https://www.gianttiger.com/collections/womens-swimwear?store_inventory=bopis&online_inventory=sth&p=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Field | Description |
|---|---|
| `urls` | Array of Giant Tiger collection or search result URLs to scrape. Include filter parameters (e.g., `?store_inventory=bopis&online_inventory=sth&p=2`) to refine results. |
| `max_items_per_url` | Maximum number of products extracted per URL. Recommended range: 20–200 depending on data volume needs. |
| `ignore_url_failures` | If `true`, the scraper skips failed URLs and continues processing. If `false`, a single URL failure halts the entire run. Set to `true` for reliable bulk operations. |

> **Tip:** Use filter parameters in your URLs to target specific product subsets — e.g., `store_inventory=bopis` for buy-online-pickup-in-store items, or `online_inventory=sth` for items in stock online.

***

### Output Format

**Sample output**

```json
{
  "grams": 0,
  "option2": "L",
  "collection_ids": [
    272700506173,
    272701456445,
    272716759101,
    273652121661,
    273652678717,
    274610782269,
    275501809725,
    275607584829,
    280618238013,
    284054683709,
    287400198205,
    287435063357
  ],
  "recently_ordered_count": 3,
  "variants_count": 4,
  "variants_max_price": 22,
  "product_image": "https://cdn.shopify.com/s/files/1/0557/6858/0157/files/preview_images_1628085_f_01.jpg?v=1776269597",
  "tags": [
    "coupon_group_all_but_d6",
    "coupon_group_all_but_d6_and_d9",
    "coupon_group_all_but_d9",
    "coupon_group_all_but_gift_cards",
    "coupon_group_d1_d3_d4_d5",
    "coupon_group_d5",
    "family_swimwear",
    "L1_Womens_01",
    "L2_brand_acx_active_01",
    "L2_Womens_Swimwear_01",
    "L3_Womens_Tankinis_01",
    "vacation_ready"
  ],
  "inventory_available": true,
  "weight": "0.0lb",
  "option_names": [
    "colour",
    "size"
  ],
  "object_id": null,
  "variants_min_price": 22,
  "named_tags": {
    "l1_category_en": "Women's",
    "l1_category_fr": "Pour femmes",
    "l2_category_en": "ACX Active",
    "l2_category_fr": "ACX Active",
    "l3_category_en": "Women's Tankinis",
    "l3_category_fr": "Tankinis pour femmes",
    "algolia_refresh": "1",
    "bopis": "true",
    "in_store_only": "false",
    "mms_class_id": "4",
    "mms_department_id": "5",
    "mms_mms_sub_class_id": "3",
    "mms_province_code": [
      "AB",
      "MB",
      "NB",
      "NS",
      "ON",
      "PE",
      "QC",
      "SK"
    ],
    "mms_sub_department": "501",
    "packaging_instruction": "pb",
    "parent": "1628084",
    "shippable": "true"
  },
  "inventory_policy": "deny",
  "updated_at": "2026-06-15T05:20:00.000Z",
  "highlight_result": null,
  "vendor": "ACX Active",
  "title": "ACX Active Women's Tankini Top",
  "position": 3,
  "variants_inventory_count": 993,
  "option1": "Md Pink FL10",
  "template_suffix": null,
  "sku": "1628087",
  "option3": null,
  "price": 22,
  "compare_at_price": 0,
  "named_tags_names": [
    "mms_department_id",
    "bopis",
    "L1_category_fr",
    "L2_category_en",
    "shippable",
    "L1_category_en",
    "packaging_instruction",
    "L2_category_fr",
    "mms_mms_sub_class_id",
    "in_store_only",
    "mms_class_id",
    "parent",
    "L3_category_fr",
    "algolia_refresh",
    "mms_province_code",
    "L3_category_en",
    "mms_sub_department"
  ],
  "meta": {
    "avalara": {
      "taxcode": "PC040100"
    },
    "english": {
      "collections": "Festival",
      "colour": "Md Pink FL10",
      "colour_family": "Pink",
      "fashion_type": "Women's Fashion",
      "neckline": "Scooped",
      "pattern": "Floral",
      "primary_fabric": "Polyester",
      "size_clothing": "l",
      "swimsuit_style": "Tankini",
      "unit_of_measure": "ea"
    },
    "french": {
      "collections": "Festival",
      "colour": "Floral rose",
      "colour_family": "Rose",
      "fashion_type": "Articles de mode pour femmes",
      "neckline": "Encolure dégagée",
      "option1": "Floral rose",
      "option2": "Grand",
      "pattern": "Floral",
      "primary_fabric": "Polyester",
      "product_type": "Maillots de bain",
      "size_clothing": "l",
      "swimsuit_style": "Tankini",
      "title": "Haut de tankini ACX Active pour femmes",
      "unit_of_measure": "chq",
      "variant_title": "Floral rose / Grand"
    },
    "info": {
      "amount_per_unit": "1.0",
      "colour_swatches": "{\"1628085\":\"https://cdn.shopify.com/s/files/1/0557/6858/0157/files/1628085.jpg?v=1776266000\",\"1628086\":\"https://cdn.shopify.com/s/files/1/0557/6858/0157/files/1628085.jpg?v=1776266000\",\"1628087\":\"https://cdn.shopify.com/s/files/1/0557/6858/0157/files/1628085.jpg?v=1776266000\",\"1628088\":\"https://cdn.shopify.com/s/files/1/0557/6858/0157/files/1628085.jpg?v=1776266000\"}",
      "display_amount_per_unit": "false",
      "dr_metrics_1": 0,
      "dr_metrics_10": 0,
      "dr_metrics_2": 0,
      "dr_metrics_3": 0,
      "dr_metrics_4": 0,
      "dr_metrics_5": 0,
      "dr_metrics_6": 0,
      "dr_metrics_7": 0,
      "dr_metrics_8": 0,
      "dr_metrics_9": 0,
      "group_id": "1628084_md_pink_fl10",
      "pack_size": 1,
      "published_at": 1777884910,
      "regional_prices": {
        "r0001": {
          "compare_at_price": "2200",
          "end_date": "0001-01-01",
          "event_id": "0",
          "event_type": " ",
          "previous_price": "",
          "price": "2200"
        }
      },
      "regional_pricing": "false",
      "store_inventory": {
        "64671580221": 1,
        "67397386301": 1,
        "online": 3
      }
    }
  },
  "options": {
    "colour": "Md Pink FL10",
    "size": "L"
  },
  "variants_compare_at_price_min": null,
  "handle": "acx-active-womens-tankini-top-1",
  "requires_shipping": true,
  "taxable": true,
  "inventory_quantity": 316,
  "created_at": "2026-04-23T10:17:49.000Z",
  "variants_compare_at_price_max": null,
  "id": 7840656195645,
  "variant_title": "Md Pink FL10 / L",
  "barcode": null,
  "body_html_safe": "Enjoy sunny days in this simple tankini with adjustable straps and a scooped neckline for easy, comfortable wear.",
  "image": "https://cdn.shopify.com/s/files/1/0557/6858/0157/files/preview_images_1628085_f_01.jpg?v=1776269597",
  "published_at": "2026-05-04T04:55:10.000Z",
  "collections": [
    "womens",
    "womens-swimwear",
    "brand-acx-active",
    "coupon-group-all-but-d6-and-d9",
    "coupon-group-d1-d3-d4-d5",
    "coupon-group-all-but-gift-cards",
    "family-swimwear",
    "vacation-ready",
    "coupon-group-all-but-d6",
    "coupon-group-d5",
    "womens-tankinis",
    "coupon-group-all-but-d9"
  ],
  "price_ratio": 0,
  "price_range": "10:25",
  "product_type": "Swimwear",
  "from_url": "https://www.gianttiger.com/collections/womens-swimwear?store_inventory=bopis&online_inventory=sth"
}
```

Each scraped product returns a rich record with 41+ fields covering pricing, inventory, variants, and product attributes:

#### Product Identification & Metadata

| Field | Meaning |
|---|---|
| `ID` | Unique Giant Tiger product identifier in their system |
| `Title` | Product name as displayed on the storefront |
| `Handle` | URL-friendly slug for the product page |
| `Position` | Display position in the collection (useful for ranking analysis) |
| `Object ID` | Internal Algolia or search engine object ID |
| `Product Type` | Category classification (e.g., Swimwear, Apparel, Home Goods) |
| `Collections` | Array of collection IDs the product belongs to |
| `Collection IDs` | Numeric identifiers for each collection |
| `Tags` | Free-form tags assigned to the product |
| `Named Tags` | Structured tag names for faceted filtering |
| `Named Tags Names` | Display names of named tags |

#### Pricing & Cost

| Field | Meaning |
|---|---|
| `Price` | Current selling price in local currency |
| `Compare At Price` | Original or list price (for discount calculation) |
| `Variants Min Price` | Lowest price among all variants |
| `Variants Max Price` | Highest price among all variants |
| `Price Range` | Human-readable price span (e.g., "$10–$25") |
| `Price Ratio` | Ratio of sale price to original price |
| `Variants Compare At Price Min` | Lowest compare-at price across variants |
| `Variants Compare At Price Max` | Highest compare-at price across variants |

#### Inventory & Fulfillment

| Field | Meaning |
|---|---|
| `Inventory Quantity` | Total units in stock across all locations/channels |
| `Inventory Available` | Available inventory for immediate purchase |
| `Inventory Policy` | Stock behavior policy (e.g., allow backorder, deny when out of stock) |
| `Variants Inventory Count` | Number of inventory records across variants |
| `Requires Shipping` | Boolean indicating if the product needs physical shipping |
| `Taxable` | Boolean for tax applicability |

#### Variants & Options

| Field | Meaning |
|---|---|
| `Variants Count` | Total number of product variants (e.g., sizes, colors) |
| `Option 1`, `Option 2`, `Option 3` | Variant dimension names (e.g., "Size", "Color", "Material") |
| `Option Names` | Array of all variant option names |
| `Variant Title` | Name of a specific variant (e.g., "Red / Large") |
| `SKU` | Stock Keeping Unit for inventory management |
| `Barcode` | Product barcode or EAN code |
| `Weight` | Product weight for shipping calculations |
| `Grams` | Weight in grams |

#### Dates & Updates

| Field | Meaning |
|---|---|
| `Created At` | When the product was first added to Giant Tiger's system |
| `Updated At` | Last modification timestamp |
| `Published At` | Date the product went live on the storefront |

#### Content & Media

| Field | Meaning |
|---|---|
| `Product Image` | Primary product image URL |
| `Image` | Featured or gallery image URL |
| `Body HTML Safe` | Product description in HTML-safe format |
| `Template Suffix` | Custom template file name (if used) |

#### Behavioral & Analytics

| Field | Meaning |
|---|---|
| `Recently Ordered Count` | Number of recent orders (demand signal) |
| `Highlight Result` | Search engine highlight or boost indicator |
| `Vendor` | Brand or supplier name |
| `Meta` | Additional metadata object (may include custom fields) |

***

### How to Use

1. **Build your URLs** — Visit Giant Tiger's collections (e.g., womens-swimwear) and apply filters (store inventory, online availability). Copy the full URL including filter parameters.
2. **Configure input** — Paste URLs into the `urls` array. Set `max_items_per_url` to `200` for full pagination or lower values for sampling.
3. **Set failure handling** — Use `ignore_url_failures: true` for robust bulk runs; use `false` if you need to validate every URL.
4. **Run the scraper** — Start the actor and monitor the run log in real-time.
5. **Export & analyze** — Download results as JSON, CSV, or Excel for further processing in Python, Tableau, or your BI tool.

**Common use patterns:**

- **Pagination:** Scrape multiple pages of the same collection by appending `?p=1`, `?p=2`, etc.
- **Multi-filter:** Combine inventory filters with category filters to isolate specific product segments.
- **Sampling:** Use low `max_items_per_url` (e.g., 20) to quickly test URL structure before full runs.

***

### Use Cases & Business Value

- **Price monitoring:** Track Giant Tiger's pricing fluctuations across product categories over time
- **Inventory intelligence:** Monitor stock levels and product availability across online and store channels
- **Competitive analysis:** Compare Giant Tiger's product assortment and pricing to other Canadian retailers
- **SKU management:** Build mappings between Giant Tiger SKUs and your internal inventory system
- **Demand signals:** Use "recently ordered count" to identify trending products
- **Market research:** Analyze product range, pricing strategy, and inventory policies for retail studies

The Giant Tiger Product Search Scraper transforms pages of static product listings into actionable, structured data that powers business decisions in retail, ecommerce, and market research.

***

### Conclusion

The **Giant Tiger Product Search Scraper** is an essential tool for anyone needing reliable product intelligence from Canada's discount retail leader. With 41+ output fields covering pricing, inventory, variants, and metadata, this scraper delivers the depth and accuracy required for competitive analysis, market research, and ecommerce operations. Start scraping today and unlock insights hidden in Giant Tiger's collections.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.gianttiger.com/collections/womens-swimwear?store_inventory=bopis&online_inventory=sth&p=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.gianttiger.com/collections/womens-swimwear?store_inventory=bopis&online_inventory=sth&p=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/gianttiger-product-search-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 = {
    "urls": ["https://www.gianttiger.com/collections/womens-swimwear?store_inventory=bopis&online_inventory=sth&p=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/gianttiger-product-search-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 '{
  "urls": [
    "https://www.gianttiger.com/collections/womens-swimwear?store_inventory=bopis&online_inventory=sth&p=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/gianttiger-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gianttiger Product Search Scraper",
        "description": "Scrape product details from Giant Tiger's collection pages with precision. This scraper extracts 41+ fields including pricing, inventory levels, variants, SKUs, and product metadata — perfect for ecommerce analysts, resellers, and market researchers.",
        "version": "0.0",
        "x-build-id": "MjgaeTkUSUCF36m77"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~gianttiger-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-gianttiger-product-search-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/stealth_mode~gianttiger-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-gianttiger-product-search-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/stealth_mode~gianttiger-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-gianttiger-product-search-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": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
