# Target Product Search Scraper — Price & Stock Data (`khadinakbar/target-product-search-scraper`) Actor

Search Target.com by keyword for current and regular prices, sale flags, stock, ratings, brands, images, and product URLs. Built for price monitoring, assortment research, and shopping agents—not review text or orders. Returns validated product rows. $0.007/product + usage.

- **URL**: https://apify.com/khadinakbar/target-product-search-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 target product founds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Target Product Search Scraper — Price & Stock Data

**Target Product Search Scraper** searches Target.com by keyword and returns structured product records for price monitoring, assortment research, deal discovery, and AI-agent shopping workflows. Each result includes the Target product ID (TCIN), title, brand, current and regular prices, sale status, discount percentage, ratings, review count, stock signals, seller, product URL, and image URLs. It uses Target's public web search surface without requiring a Target login or user cookies.

The Actor is intentionally search-first. Use it to discover products and compare the results Target currently presents for one or more keywords. Do not use it for full review text, account data, order history, cart actions, or checkout automation.

### What data can I extract with Target Product Search Scraper?

| Field | Meaning |
| --- | --- |
| `tcin` | Target's stable product identifier |
| `title`, `brand` | Product name and brand |
| `currentPrice`, `regularPrice` | Current and comparison prices in USD |
| `discountPercent`, `onSale` | Calculated markdown and sale flag |
| `rating`, `reviewCount` | Aggregate customer rating signals |
| `inStock`, `shippingAvailability`, `pickupAvailability` | Availability signals reported by the active Target search route |
| `seller`, `marketplace`, `sponsored` | Seller and placement metadata |
| `productUrl`, `imageUrl`, `images` | Direct Target page and image URLs |
| `category`, `department` | Target merchandise classification when available |
| `searchQuery`, `position`, `page` | Search provenance and rank |
| `scrapedAt` | ISO 8601 extraction timestamp |

Every dataset row has the same stable keys. Optional values are explicit `null`, and array fields are always arrays. This makes the output suitable for Apify API clients, MCP clients, spreadsheets, databases, and scheduled monitoring jobs.

### When should I use this Target product scraper?

Use the Actor for:

- Retail price monitoring across recurring Target searches.
- Competitive assortment and brand-share analysis.
- Sale and markdown discovery with `saleOnly`.
- In-stock product research using Target's current search availability signals.
- Product catalog enrichment using TCIN, brand, images, ratings, and URLs.
- Shopping agents that need concise, typed Target search results.
- Cross-retailer comparisons with Amazon, eBay, AliExpress, or other catalog data.
- Scheduled datasets that can be compared over time by TCIN.

Do not use the Actor when you need review text, authenticated customer information, purchase history, cart manipulation, or guaranteed future inventory. Availability and pricing are observations at scrape time and may change afterward.

### How much will scraping Target cost you?

This Actor uses Pay per event + usage pricing.

| Event | Price |
| --- | ---: |
| Actor start | $0.00005 |
| Valid Target product saved | $0.007 |
| Apify platform usage | Additional compute and proxy usage |

The product event is charged only after a complete row passes validation and is persisted to the dataset. Invalid, duplicate, filtered, or failed records are not charged as products.

Examples:

- 20 products: $0.14005 in Actor events, plus platform usage.
- 50 products: $0.35005 in Actor events, plus platform usage.
- 100 products: $0.70005 in Actor events, plus platform usage.

The run logs its maximum possible event charge before the first product is saved. `maxResults`, Apify's paid-item limit, and `maxTotalChargeUsd` all cap product events. A typical AI-agent run stays under $1 in event charges.

### How to use Target Product Search Scraper

The default input is a small health-check-safe search for `coffee maker`. You can run the Actor with an empty `{}` input, but production workflows should set explicit keywords and limits.

#### Input example

```json
{
  "searchQueries": ["coffee maker", "espresso machine"],
  "maxResults": 50,
  "sortBy": "relevance",
  "includeSponsored": false,
  "inStockOnly": true,
  "saleOnly": false,
  "minPrice": 25,
  "maxPrice": 250,
  "responseFormat": "concise"
}
````

#### Input fields

- `searchQueries`: one to ten Target keyword searches. Duplicate queries are removed case-insensitively.
- `maxResults`: global result cap across all keywords, from 1 to 500.
- `sortBy`: `relevance` or `newest`.
- `includeSponsored`: retain sponsored placements when Target returns them.
- `inStockOnly`: remove products that are not positively identified as in stock.
- `saleOnly`: retain products whose current price is below the regular price.
- `minPrice` and `maxPrice`: USD post-filters; zero disables either bound.
- `responseFormat`: `concise` returns one image and no bullet list; `detailed` returns up to eight images and eight highlights.

Target may localize pricing or availability by session, fulfillment route, and time. Treat every row as a point-in-time search observation rather than a reservation or nationwide inventory guarantee.

#### Output example

```json
{
  "searchQuery": "coffee maker",
  "position": 1,
  "page": 1,
  "totalResults": 300,
  "tcin": "91863920",
  "title": "Mr. Coffee 12-Cup Programmable Coffee Maker Black",
  "brand": "Mr. Coffee",
  "currentPrice": 19.99,
  "regularPrice": 34.99,
  "currency": "USD",
  "discountPercent": 43,
  "onSale": true,
  "rating": 4.33,
  "reviewCount": 906,
  "inStock": true,
  "soldOut": false,
  "shippingAvailability": "IN_STOCK",
  "pickupAvailability": "IN_STOCK",
  "productUrl": "https://www.target.com/p/example/-/A-91863920",
  "imageUrl": "https://target.scene7.com/is/image/Target/GUEST_example",
  "images": ["https://target.scene7.com/is/image/Target/GUEST_example"],
  "category": "Coffee Makers",
  "department": "Kitchen",
  "seller": "Target",
  "marketplace": false,
  "sponsored": false,
  "bulletHighlights": [],
  "scrapedAt": "2026-07-15T12:00:00.000Z"
}
```

### Run Target Product Search Scraper through the API

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/target-product-search-scraper').call({
    searchQueries: ['wireless headphones'],
    maxResults: 25,
    inStockOnly: true,
    responseFormat: 'concise',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("khadinakbar/target-product-search-scraper").call(run_input={
    "searchQueries": ["wireless headphones"],
    "maxResults": 25,
    "inStockOnly": True,
    "responseFormat": "concise",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~target-product-search-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["wireless headphones"],"maxResults":25}'
```

Keep API tokens in environment variables or authorization headers. Do not place them in URLs, saved public tasks, or source code.

### MCP and AI-agent use

Apify's hosted MCP server can expose this Actor as a callable tool. The concise response format keeps each product small enough for agents to compare multiple results without crowding out reasoning context. The input schema gives agents working defaults, bounded enums, literal examples, and clear negative scope. The dataset schema declares every product field and provides dedicated overview, price-monitoring, and stock-monitoring views.

Use the tool for Target keyword product search. Route review-text requests to a dedicated Target reviews scraper, and route exact product-detail enrichment to a product-detail Actor when search results are insufficient.

### Reliability and run outcomes

The Actor dynamically reads Target's current public RedSky route from the Target search page. It tries consistent Chrome and Firefox IMPIT fingerprints, then adds Apify proxy routes when available. If Target challenges every direct route, it uses a cost-bounded Apify Target-data provider and validates that provider's rows against the same output schema. It retries transient errors without charging failed product attempts.

Every terminal path writes `OUTPUT` and `RUN_SUMMARY`:

- `COMPLETE`: all advertised work completed and useful rows were saved.
- `PARTIAL`: useful rows were saved, but some queries, rows, or routes failed.
- `VALID_EMPTY`: Target processed the query but no products matched.
- `INVALID_INPUT`: the request is user-correctable and includes a working example.
- `UPSTREAM_FAILED`: every configured Target route failed with no useful output.
- `CONFIG_ERROR`: the deployed Actor cannot run because owner-managed configuration is invalid.

Target can change its web APIs, ranking, prices, and availability without notice. A blocked run fails honestly instead of returning a silent empty dataset.

### Other dedicated ecommerce scrapers

- [Amazon Product Scraper](https://apify.com/khadinakbar/amazon-product-scraper)
- [Amazon Search Scraper](https://apify.com/khadinakbar/amazon-search-scraper)
- [Amazon Price History Scraper](https://apify.com/khadinakbar/amazon-price-history-scraper)
- [Amazon Competitor Price Tracker](https://apify.com/khadinakbar/amazon-competitor-price-tracker)
- [Amazon Reviews Scraper](https://apify.com/khadinakbar/amazon-reviews-scraper)
- [Amazon Seller Scraper](https://apify.com/khadinakbar/amazon-seller-scraper)
- [eBay All-in-One Scraper](https://apify.com/khadinakbar/ebay-all-in-one-scraper)
- [AliExpress Product Search Scraper](https://apify.com/khadinakbar/aliexpress-product-search-scraper)
- [Sephora Product Scraper](https://apify.com/khadinakbar/sephora-product-scraper)
- [PlayStation Store Scraper](https://apify.com/khadinakbar/playstation-store-scraper)

### FAQ

#### How many results can I scrape with Target Product Search Scraper?

One run can save up to 500 products. Use smaller scheduled runs for narrow price-monitoring workflows and split unrelated keyword groups into separate runs.

#### Can I integrate Target Product Search Scraper with other apps?

Yes. Use Apify integrations, webhooks, schedules, Make, Zapier, Google Sheets, or the dataset API. Stable TCIN values work well as join keys.

#### Can I use Target Product Search Scraper with the Apify API?

Yes. Start runs through the Actor API and read JSON, CSV, Excel, or other dataset exports after completion.

#### Can I use Target Product Search Scraper through an MCP Server?

Yes. Add `khadinakbar/target-product-search-scraper` to Apify's hosted MCP server. Concise mode is recommended for agent comparisons.

#### Do I need proxies to scrape Target?

No proxy input is required. The Actor tries direct IMPIT routes and adds Apify-managed proxy fallback automatically when the account supports it. Platform proxy usage is billed separately.

#### Why can price or stock differ from my browser?

Target localizes product data by session, fulfillment route, and time. Search results are point-in-time observations and can differ from a browser session or a different location.

#### Is it legal to scrape Target data?

This Actor accesses publicly available product information. You are responsible for complying with Target's terms, applicable laws, intellectual-property rules, rate limits, and your intended use. Do not use it to collect personal data or perform unauthorized account or transaction activity.

#### Your feedback

Open an issue on the Actor's Apify page with the run ID, query, expected result, and observed behavior. Never include API tokens, cookies, payment information, or private customer data.

# Actor input Schema

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

Use this when you need Target products matching one or more keywords. Enter 1-10 lines such as 'coffee maker' or 'wireless headphones'. The default is 'coffee maker'. This is not a Target product URL or TCIN lookup.

## `maxResults` (type: `integer`):

Use this to cap the total products saved across all queries. Enter an integer from 1 to 500, for example 50. The default is 20 and event charges cannot exceed this count. This is not a per-query limit.

## `sortBy` (type: `string`):

Use this to choose how Target orders each keyword search. Accepted values are relevance and newest. The default is relevance. This changes result order, not the price or stock filters.

## `includeSponsored` (type: `boolean`):

Use this when paid placements should appear with organic Target results. Set true to retain sponsored products, for example during shelf-share research. The default is false. This does not identify Target Circle promotions.

## `inStockOnly` (type: `boolean`):

Use this when the dataset should contain only products currently reported as available by the active Target search route. Set true to remove known out-of-stock records. The default is false. This does not guarantee future inventory or reserve an item.

## `saleOnly` (type: `boolean`):

Use this when only products with a current price below the regular price are useful. Set true for deal monitoring or markdown research. The default is false. This does not include coupon-only discounts when Target omits a lower current price.

## `minPrice` (type: `number`):

Use this to remove products priced below a USD threshold. Enter a non-negative number such as 25. The default 0 disables the minimum-price filter. This is not a discount-percentage filter.

## `maxPrice` (type: `number`):

Use this to remove products priced above a USD threshold. Enter a non-negative number such as 100. The default 0 disables the maximum-price filter. This is not the run's event-charge cap.

## `responseFormat` (type: `string`):

Use concise for small AI-agent outputs or detailed for alternate images and bullet highlights. Accepted values are 'concise' and 'detailed'. The default is concise. This does not change product eligibility or pricing fields.

## Actor input object example

```json
{
  "searchQueries": [
    "coffee maker",
    "wireless headphones"
  ],
  "maxResults": 50,
  "sortBy": "newest",
  "includeSponsored": false,
  "inStockOnly": true,
  "saleOnly": true,
  "minPrice": 25,
  "maxPrice": 100,
  "responseFormat": "detailed"
}
```

# Actor output Schema

## `results` (type: `string`):

All schema-valid Target product search records as JSON dataset items.

## `resultsCsv` (type: `string`):

The same product records exported as CSV.

## `output` (type: `string`):

Compact machine-readable outcome, item counts, warnings, and event-charge totals.

## `runSummary` (type: `string`):

Detailed route, pagination, filter, validation, billing, warning, and error diagnostics.

## `consoleRun` (type: `string`):

Open this run's status, logs, storage, and dataset preview in 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 = {
    "searchQueries": [
        "coffee maker"
    ],
    "maxResults": 20,
    "sortBy": "relevance",
    "includeSponsored": false,
    "inStockOnly": false,
    "saleOnly": false,
    "minPrice": 0,
    "maxPrice": 0,
    "responseFormat": "concise"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQueries": ["coffee maker"],
    "maxResults": 20,
    "sortBy": "relevance",
    "includeSponsored": False,
    "inStockOnly": False,
    "saleOnly": False,
    "minPrice": 0,
    "maxPrice": 0,
    "responseFormat": "concise",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQueries": [
    "coffee maker"
  ],
  "maxResults": 20,
  "sortBy": "relevance",
  "includeSponsored": false,
  "inStockOnly": false,
  "saleOnly": false,
  "minPrice": 0,
  "maxPrice": 0,
  "responseFormat": "concise"
}' |
apify call khadinakbar/target-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Product Search Scraper — Price & Stock Data",
        "description": "Search Target.com by keyword for current and regular prices, sale flags, stock, ratings, brands, images, and product URLs. Built for price monitoring, assortment research, and shopping agents—not review text or orders. Returns validated product rows. $0.007/product + usage.",
        "version": "1.0",
        "x-build-id": "zhtGKEX52B10Hxyp8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~target-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~target-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~target-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": {
                    "searchQueries": {
                        "title": "Target search queries",
                        "type": "array",
                        "description": "Use this when you need Target products matching one or more keywords. Enter 1-10 lines such as 'coffee maker' or 'wireless headphones'. The default is 'coffee maker'. This is not a Target product URL or TCIN lookup.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "coffee maker"
                        ]
                    },
                    "maxResults": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Use this to cap the total products saved across all queries. Enter an integer from 1 to 500, for example 50. The default is 20 and event charges cannot exceed this count. This is not a per-query limit.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Use this to choose how Target orders each keyword search. Accepted values are relevance and newest. The default is relevance. This changes result order, not the price or stock filters.",
                        "default": "relevance"
                    },
                    "includeSponsored": {
                        "title": "Include sponsored products",
                        "type": "boolean",
                        "description": "Use this when paid placements should appear with organic Target results. Set true to retain sponsored products, for example during shelf-share research. The default is false. This does not identify Target Circle promotions.",
                        "default": false
                    },
                    "inStockOnly": {
                        "title": "In-stock products only",
                        "type": "boolean",
                        "description": "Use this when the dataset should contain only products currently reported as available by the active Target search route. Set true to remove known out-of-stock records. The default is false. This does not guarantee future inventory or reserve an item.",
                        "default": false
                    },
                    "saleOnly": {
                        "title": "Sale products only",
                        "type": "boolean",
                        "description": "Use this when only products with a current price below the regular price are useful. Set true for deal monitoring or markdown research. The default is false. This does not include coupon-only discounts when Target omits a lower current price.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Use this to remove products priced below a USD threshold. Enter a non-negative number such as 25. The default 0 disables the minimum-price filter. This is not a discount-percentage filter.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Use this to remove products priced above a USD threshold. Enter a non-negative number such as 100. The default 0 disables the maximum-price filter. This is not the run's event-charge cap.",
                        "default": 0
                    },
                    "responseFormat": {
                        "title": "Response detail",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use concise for small AI-agent outputs or detailed for alternate images and bullet highlights. Accepted values are 'concise' and 'detailed'. The default is concise. This does not change product eligibility or pricing fields.",
                        "default": "concise"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
