# Target Product Search Scraper (`kawsar/target-product-search-scraper`) Actor

Target product search scraper that pulls product prices, ratings, and availability from Target.com search results and category pages, so retail analysts can collect structured data without manual browsing.

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

## Pricing

from $5.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Target Product Search Scraper: Pull Structured Product Data from Target.com at Scale

Target.com lists millions of products across thousands of categories, but getting that data into a usable format means sitting through pages of manual browsing or building brittle browser scripts that break every time the site updates. This actor solves that. Point it at any Target search URL or category browse page and it collects structured product records across all paginated results automatically, including prices, ratings, availability, brand, images, and more.

Works with keyword search pages, department category pages, filtered result pages, and subcategory browse pages. You can scrape a single URL or queue up a whole list in one run.

### What data does this actor extract?

Each product record contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `tcin` | string | Target's unique internal product ID. Use this to track and deduplicate products. |
| `productTitle` | string | Full product name as shown on the listing. |
| `brand` | string | Brand or manufacturer name. |
| `currentPrice` | number | Current selling price in USD, reflecting any active sale or promotion. |
| `regularPrice` | number | Standard non-sale price in USD. Null when no comparison price is listed. |
| `onSale` | boolean | True when the current price is lower than the regular price. |
| `averageRating` | number | Average customer rating on a 0 to 5 scale. |
| `reviewCount` | integer | Total number of customer reviews submitted for this product. |
| `url` | string | Direct link to the product page on Target.com. |
| `imageUrl` | string | URL of the primary product image. |
| `availableOnline` | boolean | True when the product can be purchased online at the time of scraping. |
| `upc` | string | Universal Product Code (barcode). Null when not returned by Target. |
| `currency` | string | Currency code for price fields. Always USD. |
| `highlights` | array | Feature bullet points from the product listing with HTML tags removed. |
| `productDescription` | string | Short product description or introductory summary text. |
| `specifications` | string | Full specifications block as raw HTML. Null for products without a spec sheet. |
| `shippingInfo` | string | Free shipping threshold message, if available. |
| `weight` | number | Package weight value. |
| `weightUnit` | string | Unit of measure for weight (e.g. LB, OZ). |
| `origin` | string | Country of origin. |
| `color` | string | Color variant of this specific item. Null for products without color variants. |
| `size` | string | Size variant of this specific item. Null for products without size options. |
| `sizeUnit` | string | Unit of measure for the size field (e.g. FL OZ). |
| `images` | array | All product image URLs: primary image first, then alternate angles. |
| `nextPage` | string | URL to the next page of results. Null on the last page or when the item limit is reached. |
| `scrapedAt` | string | ISO 8601 timestamp of when this record was collected. |

### Supported URL types

| URL pattern | What gets scraped |
|---|---|
| `https://www.target.com/s?searchTerm=<keyword>` | Keyword search results with all matching products |
| `https://www.target.com/c/<category-slug>/-/N-<id>` | Category browse page products |
| `https://www.target.com/s?sortBy=relevance&category=<id>&searchTerm=<keyword>` | Filtered or sorted search results |
| `https://www.target.com/c/<dept>/<subcat>/-/N-<id>` | Department or subcategory product listings |

### Use cases

- **Price monitoring**: track price changes on specific product categories over time by scheduling the actor to run on a recurring basis
- **Competitive research**: pull product catalogs from Target to compare against other retailers on pricing, availability, and assortment gaps
- **Inventory tracking**: monitor which products are in stock or out of stock across any category or search result set
- **Product catalog building**: collect structured product data including titles, brands, images, and prices for import into a database or spreadsheet
- **Retail analytics**: aggregate search result data across multiple keyword queries to understand how Target ranks products and surfaces brands
- **Market research**: extract product listings from department and subcategory pages to analyze pricing patterns, brand presence, and promotional activity

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `url` | string | _(required)_ | A single Target.com search or category page URL. |
| `urls` | array of strings | _(optional)_ | List of Target.com URLs to scrape in one run. One URL per line. |
| `maxItems` | integer | `100` | Maximum products to collect per URL. Set to `0` for no limit. |
| `requestDelayMs` | integer | `1000` | Milliseconds to wait between paginated page requests. Increase if you encounter rate limiting. |
| `proxyConfiguration` | object | Datacenter (US) | Proxy type and location. Datacenter proxies with United States location are recommended. |

**Note:** Either `url` or `urls` must be provided. If both are given, `url` is processed first.

#### Example input 1: keyword search

```json
{
    "url": "https://www.target.com/s?searchTerm=baking+sheet",
    "maxItems": 50,
    "requestDelayMs": 1000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
}
````

#### Example input 2: category browse page

```json
{
    "url": "https://www.target.com/c/air-fryers-kitchen-appliances-dining/-/N-ncrpx",
    "maxItems": 100,
    "requestDelayMs": 1500,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
}
```

#### Example input 3: multiple URLs in one run

```json
{
    "urls": [
        "https://www.target.com/s?searchTerm=green+sneakers",
        "https://www.target.com/s?searchTerm=running+shoes",
        "https://www.target.com/c/travelwear-commute-activewear-men-s-clothing/-/N-hyb5i"
    ],
    "maxItems": 75,
    "requestDelayMs": 1000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
}
```

#### Example input 4: filtered search with sorting

```json
{
    "url": "https://www.target.com/s?sortBy=relevance&Nao=0&category=5xu1w&searchTerm=green+sneakers",
    "maxItems": 200,
    "requestDelayMs": 2000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
}
```

#### Example input 5: no proxy (local testing)

```json
{
    "url": "https://www.target.com/s?searchTerm=cast+iron+skillet",
    "maxItems": 24
}
```

### Output

Results are saved to the Apify dataset. Each record represents one product.

Below is a sample output record:

```json
{
    "tcin": "84695745",
    "productTitle": "Nordic Ware Natural Aluminum Commercial Baker's Half Sheet",
    "brand": "Nordic Ware",
    "currentPrice": 14.99,
    "regularPrice": 17.99,
    "onSale": true,
    "averageRating": 4.8,
    "reviewCount": 3241,
    "url": "https://www.target.com/p/nordic-ware-natural-aluminum-commercial-baker-s-half-sheet/-/A-84695745",
    "imageUrl": "https://target.scene7.com/is/image/Target/GUEST_abc123",
    "availableOnline": true,
    "upc": "011172014890",
    "currency": "USD",
    "highlights": [
        "Half sheet size, great for baking, roasting, and more",
        "Made from pure aluminum for fast, even heat distribution",
        "Rolled edges prevent warping",
        "Dishwasher safe"
    ],
    "productDescription": "The perfect baking sheet for everything from cookies to roasted vegetables.",
    "specifications": null,
    "shippingInfo": "Free shipping on orders over $35.00",
    "weight": 1.2,
    "weightUnit": "LB",
    "origin": "USA",
    "color": null,
    "size": null,
    "sizeUnit": null,
    "images": [
        "https://target.scene7.com/is/image/Target/GUEST_abc123",
        "https://target.scene7.com/is/image/Target/GUEST_abc124"
    ],
    "nextPage": null,
    "scrapedAt": "2026-04-26T10:30:00.000000+00:00"
}
```

### How it works

1. **Parse the input URL** to extract the search keyword, category ID, and any filter parameters from the URL query string and path.
2. **Call the product search API** with the extracted parameters, requesting 24 products per page.
3. **Extract product data** from the JSON response, mapping each item to the output schema fields.
4. **Paginate automatically** by incrementing the offset in 24-item steps, continuing until the maximum item count is reached or no more results are returned.
5. **Deduplicate by TCIN** across all input URLs so the same product is never pushed twice in a single run.
6. **Throttle requests** using the configured delay between pages to stay within rate limits.
7. **Push results** to the Apify dataset as they are collected, so data is available before the run finishes.

### Proxy and anti-blocking

Target.com responds well to Datacenter proxies routed through US IP addresses. The actor defaults to Apify's Datacenter proxy pool with United States location, which is both fast and reliable for this use case.

If you notice empty results or HTTP 403 responses, switch to Residential proxies in the proxy configuration. Residential proxies use IP addresses assigned to real internet service providers and are harder for rate-limiting systems to detect.

The actor also rotates the proxy URL on each input URL request, so long multi-URL runs do not hammer a single IP.

### FAQ

**Can this actor scrape individual product detail pages?**
No. This actor is designed for search results and category browse pages where multiple products appear in a list. It collects the data available on those listing pages, including prices, ratings, availability, and images. For full product detail pages with extended descriptions and specifications, you would need a separate product page scraper.

**Why does `regularPrice` sometimes come back null?**
Target only shows a comparison price when a product is actively on sale. Products at their standard price do not have a `reg_retail` field in the response, so `regularPrice` will be null and `onSale` will be false.

**How many products can I scrape per run?**
The `maxItems` field caps how many products are returned per URL. The default is 100. You can set it higher or to 0 for no limit. In practice, Target search result pages typically return between a few dozen and a few hundred products before results run out, depending on the search term.

**What happens if a URL returns no results?**
The actor logs a warning and moves on to the next URL. No records are pushed for that URL, and the run does not fail. You can check the actor log for details on which URLs produced results.

**Can I run this actor on a schedule?**
Yes. Use Apify's built-in scheduler to run the actor at regular intervals. This is useful for price monitoring tasks where you want to track how prices and availability change over time. Connect the output to Google Sheets or a webhook to get automatic updates whenever new data arrives.

**Why are some fields like `color` and `size` null?**
Many products on Target are sold as single items without variant options. For those, Target does not return color or size attributes, so those fields are null. Products that come in multiple colors or sizes will have those fields populated.

**Does the actor handle pagination automatically?**
Yes. The actor pages through results automatically using the offset parameter, collecting up to `maxItems` products per URL. Each page returns 24 products. The actor stops when it reaches the item limit, runs out of results, or cannot determine the total result count.

### Integrations

Connect Target Product Search Scraper with other apps and services using [Apify integrations](https://apify.com/integrations). You can integrate with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and many more. You can also use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger actions whenever new product data is ready.

***

Collecting Target product data at scale is straightforward with this actor. Whether you need a one-time category export or ongoing price monitoring across dozens of search queries, it handles pagination, deduplication, and structured output so you can focus on what to do with the data.

# Actor input Schema

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

List of Target.com search or category URLs to scrape in one run. One URL per line. Accepts both search (/s?searchTerm=...) and category (/c/...) pages.

## `queries` (type: `array`):

Plain search terms to look up on Target.com. Each term is automatically converted to a search URL — no need to build URLs manually. One search term per line.

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

Maximum number of products to collect per URL or search query. The actor paginates automatically (24 products per page) until this limit is reached. Set to 0 for no limit.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between paginated page requests. Increase this value if you encounter rate limiting or empty responses.

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

When enabled, makes one extra API call per product to retrieve fields that are not in the search listing: specifications, weight, dimensions, country of origin, shipping info, color/size variants, and full image gallery. Produces complete records but is slower — plan for roughly 1 second per product.

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

Select proxies for requests. Target works reliably with Datacenter proxies set to United States. Switch to Residential if you experience blocks.

## Actor input object example

```json
{
  "urls": [
    "https://www.target.com/s?searchTerm=baking+sheet"
  ],
  "queries": [
    "baking sheet",
    "air fryer"
  ],
  "maxItems": 100,
  "requestDelayMs": 1000,
  "fetchProductDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# 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.target.com/s?searchTerm=baking+sheet"
    ],
    "queries": [
        "baking sheet",
        "air fryer"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/target-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.target.com/s?searchTerm=baking+sheet"],
    "queries": [
        "baking sheet",
        "air fryer",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/target-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.target.com/s?searchTerm=baking+sheet"
  ],
  "queries": [
    "baking sheet",
    "air fryer"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call kawsar/target-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Product Search Scraper",
        "description": "Target product search scraper that pulls product prices, ratings, and availability from Target.com search results and category pages, so retail analysts can collect structured data without manual browsing.",
        "version": "0.0",
        "x-build-id": "hedNrhGF8K2Ldd9ep"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~target-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-target-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/kawsar~target-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-target-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/kawsar~target-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-target-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": "Multiple Target.com URLs",
                        "type": "array",
                        "description": "List of Target.com search or category URLs to scrape in one run. One URL per line. Accepts both search (/s?searchTerm=...) and category (/c/...) pages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Plain search terms to look up on Target.com. Each term is automatically converted to a search URL — no need to build URLs manually. One search term per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items per URL / query",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to collect per URL or search query. The actor paginates automatically (24 products per page) until this limit is reached. Set to 0 for no limit.",
                        "default": 100
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Milliseconds to wait between paginated page requests. Increase this value if you encounter rate limiting or empty responses.",
                        "default": 1000
                    },
                    "fetchProductDetails": {
                        "title": "Fetch full product details",
                        "type": "boolean",
                        "description": "When enabled, makes one extra API call per product to retrieve fields that are not in the search listing: specifications, weight, dimensions, country of origin, shipping info, color/size variants, and full image gallery. Produces complete records but is slower — plan for roughly 1 second per product.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies for requests. Target works reliably with Datacenter proxies set to United States. Switch to Residential if you experience blocks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
