# Target.com Product Scraper (`alwaysprimedev/target-scraper`) Actor

Scrape Target.com product details — title, price, brand, images, ratings, variants, specs — from search keywords, category pages, or product URLs.

- **URL**: https://apify.com/alwaysprimedev/target-scraper.md
- **Developed by:** [Always Prime](https://apify.com/alwaysprimedev) (community)
- **Categories:** E-commerce, SEO tools, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 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.com Product Scraper

> ⚡️ Blazing-fast, structured product data from Target.com — straight from Target's own data layer, no browser, no HTML parsing.

[![Apify](https://img.shields.io/badge/Run%20on-Apify-blueviolet)](https://apify.com/)
[![Python](https://img.shields.io/badge/python-3.11-blue.svg)]()
[![Formats](https://img.shields.io/badge/output-JSON%20%7C%20CSV%20%7C%20Excel-success)]()

### 🚀 Why this scraper?

- 🔌 **Direct data access** — pulls clean JSON from Target's structured catalog, not from rendered HTML.
- ⚡️ **~70 KB per product** — tiny payloads, sub-second per item, very cheap to run at scale.
- 📦 **Full product schema** — title, brand, current price, regular price, all images, every feature bullet, full specifications, ratings, reviews, breadcrumb categories, and every variant (size/color) with its own price and image.
- 🎯 **Three input modes** — keyword search, category browse, or specific product URLs. Pick what fits.
- 💰 **Variant-aware pricing** — automatically detects price-range items (e.g. T-shirts $8–$12) and ships per-variant prices for every size/color.
- 🛡️ **Honeypot detection** — internal cross-check flags poisoned listings; you don't pay for bad data.
- 🤖 **Resilient by default** — TLS-fingerprint rotation, structured retry, and fast-fail when something looks wrong.

### 🏁 Quick start

1. Click **Try for free** at the top of this page.
2. Pick an input mode and fill in keywords / categories / URLs.
3. Click **Start**.
4. Download results as **JSON, CSV, or Excel** when the run finishes.

That's it — no setup, no API keys, no proxies to configure.

### 📥 Input

| Field             | What it does                                                                                       | Example                                        |
| ----------------- | -------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
| `searchType`      | One of `keyword`, `category`, `url`. Picks which input list is used.                               | `keyword`                                      |
| `queries`         | List of search terms. Used when `searchType = keyword`.                                            | `["airpods", "lego star wars"]`                |
| `categories`      | List of Target category node IDs (the part after `N-` in URLs like `target.com/c/grocery/-/N-5xt1a`). | `["5xt1a"]`                                  |
| `startUrls`       | Direct product URLs. The actor reads the TCIN from `/A-<tcin>`.                                    | `["https://www.target.com/p/-/A-1000000076"]`  |
| `maxItems`        | Stop after this many products. `0` = unlimited.                                                    | `50`                                           |
| `scrapeDetails`   | When `false`, returns only URL + TCIN from list pages (cheap diff mode).                           | `true`                                         |
| `concurrency`     | Detail requests in parallel (1–25).                                                                | `5`                                            |
| `storeId`         | Target store ID; pricing varies by store.                                                          | `1414`                                         |
| `zipCode`         | ZIP for fulfillment context.                                                                       | `12401`                                        |
| `stateCode`       | Two-letter state code.                                                                             | `NY`                                           |

### 📤 Output

Each product is one record. Sample:

```json
{
  "url": "https://www.target.com/p/campus-lab-uam-hoodie/-/A-1000000076",
  "id": "1000000076",
  "tcin": "1000000076",
  "dpci": "081-04-9999",
  "upc": "196760123456",
  "title": "Campus Lab University of Arkansas at Monticello Boll Weevils Logo Adult Pull-Over Hoodie - Heather Gray",
  "brand": "Campus Lab",
  "brand_url": "/b/campus-lab/-/N-aaa1",
  "description": "Show your school spirit with this Campus Lab pullover hoodie featuring the official UAM Boll Weevils logo.",
  "bullets": [
    "Soft fleece interior for warmth",
    "Officially licensed collegiate apparel",
    "Front kangaroo pocket"
  ],
  "product_type": "APPAREL",
  "item_type": "Sweatshirts",
  "primary_image_url": "https://target.scene7.com/is/image/Target/GUEST_23f20057",
  "image_urls": [
    "https://target.scene7.com/is/image/Target/GUEST_alt1",
    "https://target.scene7.com/is/image/Target/GUEST_alt2"
  ],
  "specifications": [
    {"name": "Material", "value": "50% Cotton, 50% Polyester"},
    {"name": "UPC", "value": "196760123456"}
  ],
  "category_id": "551v0",
  "category_name": "Graphic Sweatshirts and Hoodies",
  "breadcrumbs": [
    {"name": "Target", "url": "/"},
    {"name": "Clothing, Shoes & Accessories", "url": "/c/clothing-shoes-accessories/-/N-5xst5"},
    {"name": "Hoodies & Sweatshirts", "url": "/c/hoodies-sweatshirts-women-s-clothing/-/N-551v0"}
  ],
  "currency": "USD",
  "current_price": 39.99,
  "current_price_min": null,
  "current_price_max": null,
  "reg_price": 49.99,
  "formatted_current_price": "$39.99",
  "is_price_range": false,
  "rating": 4.5,
  "rating_count": 28,
  "review_count": 28,
  "recommended_count": 25,
  "variants": [],
  "in_store_only": false,
  "_suspicious": false,
  "scraped_at": "2026-05-21T18:30:00+00:00"
}
````

### 💼 Use cases

| Who                  | What for                                                                                          |
| -------------------- | ------------------------------------------------------------------------------------------------- |
| 🛒 Price monitoring  | Daily price-and-stock tracking on competitor SKUs; alert on drops/raises.                         |
| 📈 Market research   | Catalog-wide pricing distribution, brand share, category depth for retail analytics.              |
| 🤝 Arbitrage / resale| Find under-priced items vs. Amazon/Walmart in real time, with full identifiers (UPC, TCIN, DPCI). |
| 🎨 Catalog enrichment| High-quality images + structured bullets + specs to fill your own product catalog.                |
| 🧠 ML / training     | Clean, normalised, multi-modal product data for retail vision/NLP models.                         |
| 🛍️ Affiliate sites   | Build niche product comparison pages with auto-refreshed prices.                                  |

### 💡 Tips & tricks

- **Start small** — set `maxItems: 25` for your first run to validate fields, then scale up.
- **Cheap incremental refresh** — set `scrapeDetails: false` for a daily TCIN-only diff against yesterday's dataset; re-fetch full details only for new TCINs.
- **Pricing varies by store** — change `storeId` / `zipCode` / `stateCode` to scrape a specific market (e.g. NYC `10001`, LA `90001`).
- **`_suspicious: true`** — the actor cross-checks formatted vs. numeric prices and flags inconsistent records. Filter these out, or audit them; they're rare.
- **Variants** — apparel / multi-size items return `is_price_range: true` and a populated `variants` array; iterate that for per-SKU data.

### ❓ FAQ

**What's a TCIN / DPCI / UPC?**
TCIN is Target's own product ID (also in every product URL after `/A-`). DPCI is the in-store SKU (`Department-Class-Item`). UPC is the universal barcode shared across retailers — useful for cross-retailer joins.

**Will I get rate-limited?**
Concurrency defaults to 5, which is well below typical limits. If you hit rate-limits at higher concurrency, lower it — the actor will fail-fast (not silently degrade) so you'll know.

**Can I scrape store locations / store-only items?**
This actor focuses on product data. Each product record includes the store-specific price; for store-locator data we recommend a dedicated actor.

**Does the actor handle pagination?**
Yes — categories and keyword searches paginate automatically until `maxItems` or the end of results.

**Why is `current_price` null on some items?**
Variant parent items show `current_price_min` / `current_price_max` instead (apparel, multi-size, multi-pack). The `is_price_range` flag tells you which mode the item is in.

### 🛟 Support

Found a field that's wrong, missing, or always-null on a category you care about? Tell us via the actor's Issues tab — we treat field bugs as P0.

# Actor input Schema

## `searchType` (type: `string`):

Choose how Target should be queried. 'keyword' uses the search bar, 'category' browses a category node, 'url' scrapes specific product URLs.

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

One or more search terms (used when input mode is 'keyword'). Example: 'airpods', 'lego star wars'.

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

One or more Target category node IDs (used when input mode is 'category'). Find them in URLs like target.com/c/grocery/-/N-5xt1a — the part after 'N-' is the node ID.

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

Direct Target.com product URLs (used when input mode is 'url'). The TCIN — last digits after '/A-' — is what we scrape.

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

Stop after pushing this many products to the dataset. Set to 0 for unlimited (use with care on broad categories).

## `scrapeDetails` (type: `boolean`):

When ON, fetches each product's full detail (slower, complete data). When OFF, returns only the URL and TCIN from list pages — useful for cheap diff runs.

## `concurrency` (type: `integer`):

How many product detail pages to fetch in parallel. Increase for speed; lower if you see rate-limits.

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

Target store ID used for pricing and stock context (defaults to a Midwest store with broad assortment). Pricing can differ by store.

## `zipCode` (type: `string`):

ZIP code used for shipping/fulfillment calculations.

## `stateCode` (type: `string`):

Two-letter US state code matching the ZIP code above.

## Actor input object example

```json
{
  "searchType": "keyword",
  "queries": [
    "airpods"
  ],
  "categories": [],
  "startUrls": [],
  "maxItems": 50,
  "scrapeDetails": true,
  "concurrency": 5,
  "storeId": "1414",
  "zipCode": "12401",
  "stateCode": "NY"
}
```

# Actor output Schema

## `products` (type: `string`):

Full product dataset as JSON.

## `productsCsv` (type: `string`):

Same dataset as a CSV download.

## `productsXlsx` (type: `string`):

Same dataset as an Excel workbook.

## `consoleView` (type: `string`):

View the full dataset interactively in the Apify Console.

# 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 = {
    "queries": [
        "airpods"
    ],
    "categories": [],
    "startUrls": [],
    "maxItems": 50,
    "concurrency": 5,
    "storeId": "1414",
    "zipCode": "12401",
    "stateCode": "NY"
};

// Run the Actor and wait for it to finish
const run = await client.actor("alwaysprimedev/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 = {
    "queries": ["airpods"],
    "categories": [],
    "startUrls": [],
    "maxItems": 50,
    "concurrency": 5,
    "storeId": "1414",
    "zipCode": "12401",
    "stateCode": "NY",
}

# Run the Actor and wait for it to finish
run = client.actor("alwaysprimedev/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 '{
  "queries": [
    "airpods"
  ],
  "categories": [],
  "startUrls": [],
  "maxItems": 50,
  "concurrency": 5,
  "storeId": "1414",
  "zipCode": "12401",
  "stateCode": "NY"
}' |
apify call alwaysprimedev/target-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target.com Product Scraper",
        "description": "Scrape Target.com product details — title, price, brand, images, ratings, variants, specs — from search keywords, category pages, or product URLs.",
        "version": "0.1",
        "x-build-id": "SHgrgz9SAdY2ifTrN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alwaysprimedev~target-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alwaysprimedev-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/alwaysprimedev~target-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alwaysprimedev-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/alwaysprimedev~target-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alwaysprimedev-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",
                "properties": {
                    "searchType": {
                        "title": "Input mode",
                        "enum": [
                            "keyword",
                            "category",
                            "url"
                        ],
                        "type": "string",
                        "description": "Choose how Target should be queried. 'keyword' uses the search bar, 'category' browses a category node, 'url' scrapes specific product URLs.",
                        "default": "keyword"
                    },
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One or more search terms (used when input mode is 'keyword'). Example: 'airpods', 'lego star wars'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Category node IDs",
                        "type": "array",
                        "description": "One or more Target category node IDs (used when input mode is 'category'). Find them in URLs like target.com/c/grocery/-/N-5xt1a — the part after 'N-' is the node ID.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Direct Target.com product URLs (used when input mode is 'url'). The TCIN — last digits after '/A-' — is what we scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max products",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after pushing this many products to the dataset. Set to 0 for unlimited (use with care on broad categories)."
                    },
                    "scrapeDetails": {
                        "title": "Scrape full product details",
                        "type": "boolean",
                        "description": "When ON, fetches each product's full detail (slower, complete data). When OFF, returns only the URL and TCIN from list pages — useful for cheap diff runs.",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Concurrent detail requests",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many product detail pages to fetch in parallel. Increase for speed; lower if you see rate-limits."
                    },
                    "storeId": {
                        "title": "Store ID",
                        "type": "string",
                        "description": "Target store ID used for pricing and stock context (defaults to a Midwest store with broad assortment). Pricing can differ by store."
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "ZIP code used for shipping/fulfillment calculations."
                    },
                    "stateCode": {
                        "title": "State code",
                        "type": "string",
                        "description": "Two-letter US state code matching the ZIP code above."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
