# Tesco UK & Ireland Scraper - Prices, GTIN & Nutrition (`vulnv/tesco-scraper`) Actor

Scrape Tesco UK and Ireland groceries by category, keyword or URL. Get GTIN/EAN barcode, brand, price, unit price, Clubcard promotions, availability, category taxonomy, images, ratings, ingredients, allergens and nutrition. Export to JSON, CSV or Excel.

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

## Pricing

$2.00 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Tesco UK & Ireland Scraper

Extract **Tesco groceries** product data at scale - **GTIN/EAN barcode**, price, unit price,
**Clubcard promotions**, availability, full category taxonomy, images, ratings and, from the
product page, **ingredients, allergens and nutrition** - as clean, structured JSON.

Scrape by **category**, by **search keyword**, or by pasting **Tesco URLs**. Works on both
**tesco.com (UK)** and **tesco.ie (Ireland)**.

### 🚀 How to use

1. Click **Try for free** / **Start**.
2. Choose a **Region** (UK or Ireland) and pick your **Categories** - or type a **search
   keyword**, or paste **Tesco URLs** (product, category or search pages).
3. Set **Max products** (and **Max pages per listing** for big crawls).
4. Run the Actor and download results as **JSON, CSV, Excel, HTML or via API**.

### ✨ Features

- 🏷️ **Barcode-grade identifiers** - `gtin` (EAN/UPC barcode), plus Tesco's internal `tpnb`
  and `tpnc` product numbers, so records join cleanly onto your own catalogue.
- 💷 **Complete pricing** - shelf price, **unit price** (per kg / litre / each) and the
  **Clubcard price** parsed out of the offer, so loyalty pricing is a first-class field.
- 🎟️ **Promotions** - the full offer text, a Clubcard flag and a promotion count, covering
  simple price cuts, multibuys and meal deals.
- 📦 **Availability** - stock status, whether the item is for sale, and the reason when it
  is not available.
- 🗂️ **Four-level taxonomy** - super department, department, aisle and shelf, plus a
  ready-to-read `categoryPath`.
- 🥗 **Label data** - description, pack size, **ingredients**, **allergens**, the
  **nutrition table**, kcal per 100 g/ml, storage advice and dietary icons (vegan, gluten
  free, and so on). Multipacks are handled per component.
- 🏭 **Brand on every record** - including listing-only runs, so brand-share analysis needs
  no extra lookups.
- ⭐ **Ratings and reviews** - average rating and total review count on every record, with
  the 10 most recent reviews available on request.
- 🇬🇧🇮🇪 **Both stores** - UK and Ireland, each with the right currency (GBP / EUR) and its
  own category set.
- ⚡ **Fast and efficient** - a single request returns up to 1,000 products, so a
  1,000-product price sweep is one request, not forty.

### 🧭 Input

Provide at least one of `categories`, `keyword` or `urls`. Everything else is optional.

| Field | Type | Description |
|-------|------|-------------|
| `region` | string | `UK` (tesco.com) or `IE` (tesco.ie). Default `UK`. Ignored for entries in `urls`, where the region comes from the URL. |
| `categories` | array | Category slugs to scrape, e.g. `fresh-food`, `bakery`, `drinks`. Use `all` for every category in the selected region. Default `["fresh-food"]`. |
| `keyword` | string | Search the store for a term, e.g. `oat milk`. |
| `urls` | array | Tesco product, category or search URLs. Product URLs are fetched directly; listings are paginated. |
| `maxItems` | integer | Stop after this many products across the whole run. Default `200`. |
| `maxPages` | integer | Listing pages to walk per category / search / listing URL. Each page holds up to 1,000 products. Default `1`. |
| `pageOffset` | integer | First listing page to fetch, for resuming a large crawl. Default `1`. |
| `includeProductDetails` | boolean | Add description, pack size, ingredients, allergens, nutrition and storage. Fetched in batches, so it costs roughly one extra request per 15 products. Default `true`. |
| `includeReviews` | boolean | Add the 10 most recent customer reviews per product. Default `false`. |
| `onlyUnique` | boolean | Drop repeats when a product appears in more than one category or page. Default `true`. |

The item budget is **shared across your listing sources**: asking for three categories and
300 products returns roughly 100 of each, rather than 300 of the first one.

#### Example input

```json
{
  "region": "UK",
  "categories": ["fresh-food", "bakery"],
  "maxItems": 400,
  "maxPages": 2,
  "includeProductDetails": true,
  "includeReviews": false
}
````

A fast price-and-stock sweep - listing data only, no product pages:

```json
{
  "region": "UK",
  "categories": ["all"],
  "maxItems": 5000,
  "maxPages": 25,
  "includeProductDetails": false
}
```

### 📤 Output

One record per product. Abridged example (a Clubcard-promoted item, with details on):

```json
{
  "productId": "295673143",
  "tpnc": "295673143",
  "tpnb": "83149536",
  "gtin": "05054775188239",
  "title": "Tesco Sweet Peppers 500G",
  "brand": "TESCO",
  "url": "https://www.tesco.com/groceries/en-GB/products/295673143",
  "region": "UK",

  "currency": "GBP",
  "price": 2.1,
  "priceText": "£2.10",
  "unitPrice": 4.2,
  "unitOfMeasure": "kg",
  "unitPriceText": "£4.20/kg",
  "clubcardPrice": 1.75,
  "onPromotion": true,
  "isClubcardPrice": true,
  "promotionCount": 1,
  "promotionText": "£1.75 Clubcard Price",

  "status": "AvailableForSale",
  "isAvailable": true,
  "isForSale": true,
  "isNew": false,

  "superDepartment": "Fresh Food",
  "department": "Fresh Fruit & Vegetables",
  "aisle": "Fresh Salad & Prepared Vegetables",
  "shelf": "Peppers",
  "categoryPath": "Fresh Food > Fresh Fruit & Vegetables > Fresh Salad & Prepared Vegetables > Peppers",

  "imageUrl": "https://digitalcontent.api.tesco.com/v2/media/ghs/...jpeg",
  "imageCount": 1,
  "images": ["https://digitalcontent.api.tesco.com/v2/media/ghs/...jpeg"],

  "averageRating": 4.5,
  "reviewCount": 147,

  "packSize": "500G",
  "description": "Sweet peppers.",
  "ingredients": "Pepper",
  "allergensText": "",
  "nutritionText": "Typical Values: 100g contains; Energy: 107kJ / 25kcal; Fat: 0.2g; Saturates: 0.1g; Sugars: 4.4g; Salt: <0.01g",
  "energyKcalPer100": 25,
  "storage": "Keep refrigerated.",
  "foodIcons": ["Suitable for Vegetarians"],
  "nutritionTable": [
    { "name": "Energy", "value1": "107kJ / 25kcal", "value2": "91kJ / 22kcal" }
  ],
  "detailSections": [
    { "name": "", "ingredients": ["Pepper"], "nutrition": [] }
  ],

  "productType": "SingleProduct",
  "isMarketplace": false,
  "bulkBuyLimit": 99,
  "searchTerm": "",
  "sourceUrl": "https://www.tesco.com/groceries/en-GB/shop/fresh-food/all",
  "scrapedAt": "2026-07-26T11:36:12+00:00"
}
```

The flat fields are what the dataset table and CSV/Excel exports show. `nutritionTable`,
`detailSections`, `images` and `reviews` are nested for programmatic use - `detailSections`
carries the per-component label data for multipacks, where one product has several
ingredient lists and nutrition tables.

#### Dataset views

- **Products** - price, promotion, availability and taxonomy for every product.
- **Ingredients & nutrition** - the label data, when `includeProductDetails` is on.
- **Reviews** - per-product reviews, when `includeReviews` is on.

### 💡 Use cases

- **Grocery price monitoring** - track shelf and Clubcard prices across categories daily.
- **Competitor and market analysis** - compare pricing and range between UK and Ireland.
- **Product catalogue enrichment** - match by `gtin` and pull in images, descriptions and
  nutrition.
- **Food and nutrition research** - ingredients, allergens and nutrition tables at scale.
- **Availability and range tracking** - detect delistings, new lines and out-of-stock items.

### 📋 Notes and limits

- Reviews come from the product page, which publishes the **10 most recent** reviews per
  product. The **overall rating and total review count** are always included, whether or not
  `includeReviews` is on.
- `includeProductDetails` adds roughly one request per 15 products. For the largest price
  sweeps you can still turn it off: listing data alone carries price, unit price,
  promotions, availability, taxonomy, brand, image and rating.
- Fields that Tesco does not publish for a product come back empty - not every item has
  ingredients, allergens or a nutrition table.
- Clubcard prices are read from the offer as Tesco advertises it. Basket-level offers
  (multibuys such as "Any 2 for £5", and meal deals) leave `clubcardPrice` empty on purpose,
  because the advertised figure is a basket total rather than this product's price.
- Very deep pagination on a broad category is bounded by Tesco's own result total, reported
  in the run log as the products available for each listing.

### 💳 Pricing

This Actor is monetized **pay-per-event**: you pay a flat rate per product returned, and
nothing else.

- **No Actor start fee** - runs that return nothing cost nothing.
- **No platform usage charges** - Apify compute is included in the per-product rate.
- **No plan tiers** - the same rate whether you are on Free or Business.

Free-plan users can try it with a capped sample per run. See the **Pricing** tab on the
Actor's page for the current rate.

### ❓ FAQ

**Is scraping Tesco data legal?**
The Actor collects only publicly available product information published on Tesco's
storefront. It reads no personal data and needs no login. As with any scraping, use the data
responsibly and in line with applicable laws and the site's terms.

**Is this an official Tesco product?**
No. This is an unofficial Actor and is not affiliated with, endorsed by, or sponsored by
Tesco. "Tesco" and "Clubcard" are trademarks of their respective owners.

**Can I get barcodes?**
Yes - `gtin` is the product's EAN/UPC barcode, and every record also carries Tesco's `tpnb`
and `tpnc` numbers.

**How do I get the Clubcard price?**
The `clubcardPrice` field holds the per-unit Clubcard price where Tesco advertises one, with
`isClubcardPrice` flagging it and `promotionText` giving the full offer wording. Basket-level
offers (multibuys such as "Any 2 for £5", and meal deals) intentionally leave `clubcardPrice`
empty, because the advertised figure is a basket total rather than this product's price -
read `promotionText` for those.

**How do I scrape a whole category?**
Set `maxPages` high enough to cover it - each page holds up to 1,000 products, and the run log
reports how many products the category holds. For a full store sweep, use
`categories: ["all"]` with `includeProductDetails` off.

**How do I test cheaply?**
Set `maxItems` to a small number, e.g. 5.

**Can I resume a large crawl?**
Yes - use `pageOffset` to start from the page where a previous run stopped.

### 🛠️ Our Other Scrapers

Explore our full suite of scraping tools to power your data needs:

- **[Amazon Product Scraper](https://apify.com/vulnv/amazon-product-scraper)** — Extract Amazon product data, pricing and reviews.
- **[1688 Wholesale Scraper](https://apify.com/vulnv/1688-wholesale-scraper)** — Wholesale products, tiered pricing and suppliers from 1688.com.
- **[Yelp Business Scraper](https://apify.com/vulnv/yelp-scraper)** — Scrape Yelp business listings, ratings and contact details.
- **[Email Validator](https://apify.com/vulnv/email-validator)** — Validate and verify email addresses at scale.

📬 **Need help or have a feature request?** Contact us at <support@vulnv.com> or visit our [Apify profile](https://apify.com/vulnv).

# Actor input Schema

## `region` (type: `string`):

Which Tesco store to scrape. Ignored for entries in 'Tesco URLs', where the region is taken from the URL itself.

## `categories` (type: `array`):

Grocery categories to scrape. Leave empty if you are using a keyword or URLs instead. Some categories exist in only one of the two stores, as marked.

## `keyword` (type: `string`):

Search the store for a product term, e.g. 'oat milk'. Runs in addition to any categories or URLs you set.

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

Product, category or search URLs to scrape. Product URLs are fetched directly; category and search URLs are paginated like any other listing.

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

Stop after this many products across the whole run. Free-plan users are capped at 50 per run.

## `maxPages` (type: `integer`):

How many listing pages to walk per category, search or listing URL. Each page holds up to 1,000 products.

## `pageOffset` (type: `integer`):

First listing page to fetch. Use it to resume a large crawl where a previous run stopped.

## `includeProductDetails` (type: `boolean`):

Adds description, pack size, ingredients, allergens, nutrition and storage. Fetched in batches of 15, so it is cheap; turn it off only for the largest price-and-stock sweeps.

## `includeReviews` (type: `boolean`):

Add the 10 most recent customer reviews to each product, as published on the product page. The overall rating and total review count are always included, with or without this option.

## `onlyUnique` (type: `boolean`):

Drop repeats when the same product appears in more than one category, search or page.

## Actor input object example

```json
{
  "region": "UK",
  "categories": [
    "fresh-food"
  ],
  "keyword": "oat milk",
  "maxItems": 200,
  "maxPages": 1,
  "pageOffset": 1,
  "includeProductDetails": true,
  "includeReviews": false,
  "onlyUnique": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("vulnv/tesco-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("vulnv/tesco-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 '{}' |
apify call vulnv/tesco-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tesco UK & Ireland Scraper - Prices, GTIN & Nutrition",
        "description": "Scrape Tesco UK and Ireland groceries by category, keyword or URL. Get GTIN/EAN barcode, brand, price, unit price, Clubcard promotions, availability, category taxonomy, images, ratings, ingredients, allergens and nutrition. Export to JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "Dg3A4Vwd1EfnG48bD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vulnv~tesco-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vulnv-tesco-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/vulnv~tesco-scraper/runs": {
            "post": {
                "operationId": "runs-sync-vulnv-tesco-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/vulnv~tesco-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-vulnv-tesco-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": {
                    "region": {
                        "title": "Region",
                        "enum": [
                            "UK",
                            "IE"
                        ],
                        "type": "string",
                        "description": "Which Tesco store to scrape. Ignored for entries in 'Tesco URLs', where the region is taken from the URL itself.",
                        "default": "UK"
                    },
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Grocery categories to scrape. Leave empty if you are using a keyword or URLs instead. Some categories exist in only one of the two stores, as marked.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "all",
                                "fresh-food",
                                "bakery",
                                "frozen-food",
                                "treats-and-snacks",
                                "food-cupboard",
                                "drinks",
                                "baby-and-toddler",
                                "health-and-beauty",
                                "pets",
                                "household",
                                "home-and-furniture",
                                "home-and-living",
                                "tesco-finest",
                                "clothing-and-accessories",
                                "marketplace",
                                "electronics-and-gaming",
                                "garden-diy-and-car-care",
                                "toys-and-games",
                                "parties-and-seasonal",
                                "sports-and-leisure",
                                "hobbies-and-stationery",
                                "kiosk",
                                "inspiration-and-events"
                            ],
                            "enumTitles": [
                                "All categories in the selected region",
                                "Fresh Food",
                                "Bakery",
                                "Frozen Food",
                                "Treats & Snacks",
                                "Food Cupboard",
                                "Drinks",
                                "Baby & Toddler",
                                "Health & Beauty",
                                "Pets",
                                "Household",
                                "Home & Furniture (UK only)",
                                "Home & Living (IE only)",
                                "Tesco Finest (IE only)",
                                "Clothing & Accessories (UK only)",
                                "Marketplace (UK only)",
                                "Electronics & Gaming (UK only)",
                                "Garden, DIY & Car Care (UK only)",
                                "Toys & Games (UK only)",
                                "Parties & Seasonal (UK only)",
                                "Sports & Leisure (UK only)",
                                "Hobbies & Stationery (UK only)",
                                "Kiosk (UK only)",
                                "Inspiration & Events"
                            ]
                        },
                        "default": [
                            "fresh-food"
                        ]
                    },
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Search the store for a product term, e.g. 'oat milk'. Runs in addition to any categories or URLs you set."
                    },
                    "urls": {
                        "title": "Tesco URLs",
                        "type": "array",
                        "description": "Product, category or search URLs to scrape. Product URLs are fetched directly; category and search URLs are paginated like any other listing.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after this many products across the whole run. Free-plan users are capped at 50 per run.",
                        "default": 200
                    },
                    "maxPages": {
                        "title": "Max pages per listing",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many listing pages to walk per category, search or listing URL. Each page holds up to 1,000 products.",
                        "default": 1
                    },
                    "pageOffset": {
                        "title": "Start at page",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "First listing page to fetch. Use it to resume a large crawl where a previous run stopped.",
                        "default": 1
                    },
                    "includeProductDetails": {
                        "title": "Include product page details",
                        "type": "boolean",
                        "description": "Adds description, pack size, ingredients, allergens, nutrition and storage. Fetched in batches of 15, so it is cheap; turn it off only for the largest price-and-stock sweeps.",
                        "default": true
                    },
                    "includeReviews": {
                        "title": "Include customer reviews",
                        "type": "boolean",
                        "description": "Add the 10 most recent customer reviews to each product, as published on the product page. The overall rating and total review count are always included, with or without this option.",
                        "default": false
                    },
                    "onlyUnique": {
                        "title": "Only unique products",
                        "type": "boolean",
                        "description": "Drop repeats when the same product appears in more than one category, search or page.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
