# Target Product Scraper - Prices & Reviews (`makework36/target-scraper`) Actor

Scrape Target.com products with prices, ratings, reviews, UPC codes, and availability. Uses Target official RedSky API - no browser needed, blazing fast. Search by keyword, get detailed product data including sale prices, brands, and images.

- **URL**: https://apify.com/makework36/target-scraper.md
- **Developed by:** [deusex machine](https://apify.com/makework36) (community)
- **Categories:** E-commerce
- **Stats:** 33 total users, 8 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## Target Product Scraper — Prices, Ratings, UPC Barcodes & Inventory from Target.com

> ⭐ **Useful?** [Leave a review](https://apify.com/makework36/target-scraper/reviews) — it takes 10 seconds and is the single biggest thing that helps other ecommerce analysts find this Target scraper.

A fast, lightweight **Target.com scraper** that pulls products, prices, regular/sale prices, ratings, review counts, images, UPC barcodes, category breadcrumbs, brand info and store-level availability from Target search results. No login, no Target API key, no browser rendering — just clean JSON or CSV data. Built for price-monitoring tools, retail analysts, affiliate publishers, repricing engines, dropshippers, MAP-compliance monitors and anyone doing Target market research at scale.

### ✨ Why use this scraper

Given a list of search keywords and an optional store ID, this Target scraper queries Target's internal [RedSky aggregation API](https://redsky.target.com/) — the exact same backend that powers the Target.com storefront — and returns structured data for every product it finds. Every run pulls fresh data — Target prices move frequently (flash sales, RedCard pricing, Circle deals) and so does inventory, so the scraper hits live search results each time. You can search multiple keywords per run, control product count, switch stores for regional pricing, and optionally enrich each record with a Product Detail Page (PDP) call to pull UPC barcodes and full descriptions. Export the dataset as **JSON**, **CSV**, **Excel**, or **XML** directly from the Apify console or via the Apify API.

Because it uses raw HTTPS requests (no headless browser, no Puppeteer, no Playwright) this Target scraper is an order of magnitude cheaper and faster than browser-based alternatives. A run of 100 products on a single keyword completes in roughly 5 seconds.

Most competing Target scrapers on the Apify Store and other scraper marketplaces fall into three categories: browser-based scrapers that are expensive and slow, unofficial reverse-engineered scrapers that break every few weeks, and generic "universal retail" scrapers that miss half the fields. This Target scraper hits Target's own public RedSky API directly — the data surface is stable, documented through the same endpoints Target itself consumes, and contains every field shoppers see on the site.

### 📤 Output fields

#### Core product identity

| Field | Description |
|-------|-------------|
| `title` | Product title as shown on Target.com |
| `tcin` | Target Content Item Number — Target's unique product identifier |
| `brand` | Primary brand name (e.g. `Sony`, `Apple`, `Levi's`) |
| `url` | Direct link to the Target product page |
| `searchKeyword` | The query that surfaced this product |
| `scrapedAt` | ISO 8601 timestamp of when the record was extracted |

#### Pricing & promotions

| Field | Description |
|-------|-------------|
| `price` | Current selling price as a number (USD) |
| `regularPrice` | Regular (non-sale) retail price |
| `salePrice` | Sale price if the product is discounted, otherwise `null` |
| `savePercent` | Discount percentage (e.g. `32.5`) |
| `formattedPrice` | Price string as displayed on the page (e.g. `"$269.99"`) |

#### Ratings & social proof

| Field | Description |
|-------|-------------|
| `rating` | Average star rating on a 0–5 scale |
| `reviewCount` | Total number of customer reviews |

#### Media & images

| Field | Description |
|-------|-------------|
| `imageUrl` | Primary product image URL (Target scene7 CDN) |
| `alternateImages` | Array of additional image URLs |

#### Descriptions & specs

| Field | Description |
|-------|-------------|
| `description` | Short pipe-joined bullet summary |
| `bulletDescriptions` | Detailed bullet spec list |
| `fullDescription` | Full HTML description from the PDP (requires `fetchProductDetails`) |

#### Catalog & merchandising

| Field | Description |
|-------|-------------|
| `category` | Main category (e.g. `Headphones`, `Coffee Makers`) |
| `categoryId` | Target category identifier |
| `categoryBreadcrumbs` | Full category path (requires `fetchProductDetails`) |
| `upc` | UPC barcode (requires `fetchProductDetails`) |
| `isMarketplace` | Boolean — whether the product is sold by a third-party marketplace seller |

### 🎯 Use cases

- **Retail price monitoring** — track SKU-level prices and discount cadence across specific Target categories day-over-day.
- **MAP compliance and repricing** — brands can watch their own products on Target to enforce minimum advertised pricing.
- **Competitive analysis across big-box retailers** — combine with Walmart, Amazon and Best Buy scrapers to benchmark prices on the same UPC.
- **UPC-based catalog enrichment** — feed UPC barcodes into product databases, GS1 lookups, or marketplace onboarding flows.
- **Affiliate content & deal-alert newsletters** — surface discounts above a threshold and auto-publish deal posts linking to Target.com.
- **Dropshipping product research** — identify top-rated products by category and cross-reference against supplier catalogs.
- **Retail analytics and forecasting** — build historical pricing datasets per TCIN for demand and elasticity modeling.
- **Academic research on retail pricing** — reproducible Target.com datasets for papers on retail markdown behavior.

### 🚀 How to use

#### Basic search by keyword

```json
{
  "searchQueries": ["wireless headphones", "coffee maker"],
  "maxProducts": 50
}
````

#### Scrape with full product details (UPC, full description, breadcrumbs)

```json
{
  "searchQueries": ["running shoes"],
  "maxProducts": 25,
  "fetchProductDetails": true
}
```

Enabling `fetchProductDetails` hits the PDP API for each product to pull UPC barcodes, full HTML descriptions and the complete category breadcrumb path. This roughly 10x the run time per product but delivers a production-grade catalog record.

#### Scrape with a specific store for local pricing

```json
{
  "searchQueries": ["laptop"],
  "maxProducts": 100,
  "storeId": "1375",
  "fetchProductDetails": false
}
```

#### Scrape multiple Target categories in one run

```json
{
  "searchQueries": [
    "4k tv", "bluetooth speaker", "gaming headset",
    "air fryer", "robot vacuum", "espresso machine"
  ],
  "maxProducts": 50,
  "storeId": "3991"
}
```

### 📥 Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array<string> | — | Keywords to search on Target.com (required) |
| `maxProducts` | integer | `100` | Max products per query (1–500) |
| `storeId` | string | `"3991"` | Target store ID for local pricing and availability |
| `fetchProductDetails` | boolean | `false` | Enrich each product with UPC, full description and breadcrumbs |

### 📋 Output example

```json
{
  "title": "Sony WH-1000XM5 Wireless Noise Canceling Headphones",
  "price": 269.99,
  "regularPrice": 399.99,
  "salePrice": 269.99,
  "savePercent": 32.5,
  "formattedPrice": "$269.99",
  "brand": "Sony",
  "tcin": "86696921",
  "upc": "027242923782",
  "description": "Industry-leading noise cancellation | 30-hour battery life | Crystal clear hands-free calling",
  "fullDescription": "<p>The WH-1000XM5 headphones rewrite the rules for noise cancellation...</p>",
  "bulletDescriptions": [
    "Industry-leading noise cancellation with Auto NC Optimizer",
    "30-hour battery life with quick charging"
  ],
  "imageUrl": "https://target.scene7.com/is/image/Target/GUEST_abc123",
  "alternateImages": [
    "https://target.scene7.com/is/image/Target/GUEST_def456",
    "https://target.scene7.com/is/image/Target/GUEST_ghi789"
  ],
  "rating": 4.7,
  "reviewCount": 1842,
  "url": "https://www.target.com/p/-/A-86696921",
  "category": "Headphones",
  "categoryId": "5zja3",
  "categoryBreadcrumbs": "Electronics > Headphones > Wireless Headphones",
  "isMarketplace": false,
  "searchKeyword": "wireless headphones",
  "scrapedAt": "2026-04-22T14:30:00.000Z"
}
```

Export the full dataset as CSV directly from the Apify console, or programmatically via the Apify API.

### 💻 Code examples

#### From the Apify API (curl)

```bash
curl -X POST 'https://api.apify.com/v2/acts/makework36~target-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "searchQueries": ["wireless headphones"],
    "maxProducts": 25,
    "storeId": "3991"
  }'
```

#### From Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("makework36/target-scraper").call(run_input={
    "searchQueries": ["coffee maker", "espresso machine"],
    "maxProducts": 50,
    "fetchProductDetails": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["rating"], item.get("upc"))
```

#### From Node.js (apify-client)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('makework36/target-scraper').call({
  searchQueries: ['gaming monitor'],
  maxProducts: 40,
  storeId: '3991',
  fetchProductDetails: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items.map((p) => ({
  title: p.title,
  price: p.price,
  sale: p.salePrice,
  rating: p.rating,
})));
```

#### Export to CSV

From the console run page → *Export* → *CSV*. Or via API:

```
https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv&token=YOUR_TOKEN
```

### ⚡ Performance

- **~5 seconds for 100 products** on a single keyword with `fetchProductDetails: false`
- **~60 seconds for 100 products** with `fetchProductDetails: true` (one extra API call per product)
- Runs on minimal Apify memory (256 MB is enough)
- Paginates automatically at 24 products per page — the same page size the Target.com UI uses
- Polite 500ms delay between pages to avoid triggering rate limits
- Automatic retry with exponential backoff on HTTP 429 responses

### 📊 Comparison

There are several Target scrapers on Apify Store and elsewhere. Here's how ours stacks up on the metrics that actually matter to repricing and monitoring workflows: fields, engine, proxy model, and price.

| Feature | This Target scraper | Browser-based Target scraper | Generic retail scraper with residential proxy | Legacy HTML-only Target scraper |
|---------|---------------------|------------------------------|-----------------------------------------------|----------------------------------|
| Fields returned | **22+ (price, sale, UPC, breadcrumbs)** | 10–15, mostly visual | 8–12 generic | 5–10, price + title only |
| Scraping engine | **Raw HTTPS to RedSky API** | Headless Chromium | Browser + residential proxy | Cheerio HTML parse |
| Proxy model | Apify Proxy (free tier) | Residential (expensive) | Residential (expensive) | Datacenter only |
| UPC barcode support | **Yes** (via `fetchProductDetails`) | Rare | No | No |
| Regular vs sale price split | **Yes** | Partial | No | No |
| Store-level pricing | **Yes** (`storeId` parameter) | No | No | No |
| Multi-keyword per run | **Yes** (array input) | Limited | Yes | Yes |
| Category breadcrumbs | **Yes** | No | No | No |
| Typical cost per 1K products | **~$0.50–1.00** | $5+ | $3–$5 | $1–$2 |
| Time for 100 products | **~5s** | 2–5 min | 1–2 min | 20–40s |
| Reliability | High (official API surface) | Medium (DOM changes) | Medium | Low |

The honest take: if you only need product titles and prices for a handful of products, a generic retail scraper might be cheaper up-front. For any serious Target workflow — repricing, MAP compliance, catalog enrichment, deal hunting — the combination of UPC output, store-level pricing, sale/regular price split and API-grade reliability makes this scraper the better fit.

### 💵 Pricing

Pay-per-result model:

- **~$0.005 per Target product extracted** (price varies slightly based on `fetchProductDetails`)
- Apify gives every new user a $5 free trial → roughly 1,000 Target products to evaluate the scraper before committing
- No subscription, no minimum, no egress fees

### ❓ FAQ

#### Do I need a Target account or API key?

No. This Target scraper reads publicly available search results via Target's own RedSky API — the same backend that powers [target.com](https://www.target.com). No login, no cookies, no official Target partner access required.

#### Is scraping Target legal?

This actor only reads data that's publicly visible on Target.com search and product pages — the same data any shopper sees in a browser. Review Target's terms of service and consult legal counsel for your specific use case and jurisdiction. We don't bypass paywalls, logins, or private inventory feeds.

#### Why is this Target scraper so fast?

It uses raw HTTPS requests to the RedSky aggregation API instead of a headless browser. No JavaScript rendering, no Chromium startup, no waiting for page loads. One request → 24 products parsed.

#### Can I scrape Target reviews individually?

Not in v1 — this scraper returns aggregate review data (`rating`, `reviewCount`). Full individual review extraction is on the roadmap. Leave a comment in the [issues tab](https://apify.com/makework36/target-scraper/issues) if you need it.

#### How do I find my local Target store ID?

Go to Target.com, select *Choose Store* on any product, pick your local store, then look in the URL or the network tab for the `store_id` parameter. Common store IDs include `3991` (default), `1375`, `2775` and `1462`.

#### What about in-stock / out-of-stock?

Inventory availability at the search level is not reliably exposed. To get precise availability you'd need a fulfillment-specific endpoint call per TCIN — this is on the roadmap.

#### Does this support scraping Target by category URL?

Not directly — input is keyword-based. You can, however, pass a category-specific keyword (e.g. `"women's running shoes"`) to get category-filtered results.

#### Can I use this for RedCard member pricing?

No. RedCard pricing requires authentication. The scraper returns standard (non-RedCard) prices, which matches what guest shoppers see.

### 📝 Changelog

- **v1.1** (2026-04-22) — Full SEO rewrite, added PDP enrichment docs, Python / Node / curl examples, added anonymized comparison table, and categorized the field list.
- **v1.0** (2026-03-10) — Initial release with RedSky-based search, store-level pricing and optional PDP enrichment.

### 🔗 Related actors

- [Fast Airbnb Price Scraper](https://apify.com/makework36/fast-airbnb-price-scraper) — scrape Airbnb listings, prices, ratings and GPS coordinates
- [VRBO Scraper](https://apify.com/makework36/vrbo-scraper) — rival vacation rental marketplace coverage
- [Reddit Scraper](https://apify.com/makework36/reddit-scraper) — threads, comments and karma from Reddit
- [Booking.com Scraper](https://apify.com/makework36) — hotel prices and availability on Booking.com
- [Shopee Scraper](https://apify.com/makework36) — Southeast Asian ecommerce product data

# Actor input Schema

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

List of keywords to search on Target.com (e.g., \["laptop", "headphones", "coffee maker"]).

## `maxProducts` (type: `integer`):

Maximum number of products to scrape per search query. The RedSky API returns up to 24 products per page.

## `storeId` (type: `string`):

Target store ID used for local pricing and availability. Default is 3991 (a common Target store). Find your store ID from the Target website URL.

## `fetchProductDetails` (type: `boolean`):

If enabled, fetches additional details (UPC, full description, category breadcrumbs) for each product via the PDP API. This is slower but provides richer data.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop"
  ],
  "maxProducts": 100,
  "storeId": "3991",
  "fetchProductDetails": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped items in the default dataset (JSON).

## `csv` (type: `string`):

Default dataset formatted as CSV for spreadsheets (Google Sheets, Excel).

# 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 = {
    "searchQueries": [
        "laptop"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("makework36/target-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 = { "searchQueries": ["laptop"] }

# Run the Actor and wait for it to finish
run = client.actor("makework36/target-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 '{
  "searchQueries": [
    "laptop"
  ]
}' |
apify call makework36/target-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Product Scraper - Prices & Reviews",
        "description": "Scrape Target.com products with prices, ratings, reviews, UPC codes, and availability. Uses Target official RedSky API - no browser needed, blazing fast. Search by keyword, get detailed product data including sale prices, brands, and images.",
        "version": "0.1",
        "x-build-id": "AjkNVYR3tOBfKogl2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/makework36~target-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-makework36-target-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/makework36~target-scraper/runs": {
            "post": {
                "operationId": "runs-sync-makework36-target-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/makework36~target-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-makework36-target-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",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of keywords to search on Target.com (e.g., [\"laptop\", \"headphones\", \"coffee maker\"]).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "Max Products per Query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of products to scrape per search query. The RedSky API returns up to 24 products per page.",
                        "default": 100
                    },
                    "storeId": {
                        "title": "Target Store ID",
                        "type": "string",
                        "description": "Target store ID used for local pricing and availability. Default is 3991 (a common Target store). Find your store ID from the Target website URL.",
                        "default": "3991"
                    },
                    "fetchProductDetails": {
                        "title": "Fetch Product Details",
                        "type": "boolean",
                        "description": "If enabled, fetches additional details (UPC, full description, category breadcrumbs) for each product via the PDP API. This is slower but provides richer data.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```