# Target Product Reviews Scraper (`automation-lab/target-product-reviews-scraper`) Actor

Extract public Target reviews, ratings, text, authors, verified-purchase signals, helpfulness, customer media, secondary scores, and product rating totals. Export JSON, CSV, or Excel and schedule recurring monitoring.

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

## Pricing

Pay per event

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/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 Reviews Scraper

Export **public Target customer reviews** from product URLs or TCINs.
Get review text, star ratings, authors, dates, verified-purchase signals,
recommendations, helpfulness, customer media, secondary scores, and product rating totals.
No Target login or private API key is required.

Use the results in JSON, CSV, Excel, XML, RSS, or HTML,
or connect the Actor to a scheduled review-monitoring workflow through the Apify API.

### What does Target Product Reviews Scraper do?

Target Product Reviews Scraper turns Target product review feeds into one clean dataset row per review.
Add a product URL such as `https://www.target.com/p/-/A-13521110`,
or provide its numeric TCIN directly.
The Actor follows Target's public paginated review data rather than stopping at the few reviews visible in initial page state.

For each review, it can extract:

- ⭐ Review rating, title, text, and submission date
- 👤 Reviewer nickname and public external reviewer ID
- ✅ Verified-purchase, recommended, incentivized, syndicated, and ratings-only signals
- 👍 Helpful, unhelpful, and inappropriate-feedback counts
- 📷 Public customer photo and video URLs when exposed
- 📊 Secondary dimensions such as quality, value, comfort, and fit
- 🧮 Aggregate average, rating count, written-review count, recommendation percentage, and 1–5 star distribution
- 🛍️ Product TCIN, title, brand, canonical URL, image, and category when available

The primary route is HTTP-based and runs with 256 MB of memory,
keeping scheduled review exports lighter than a browser-only workflow.

### Who is Target Product Reviews Scraper for?

**Ecommerce brands and marketplace sellers**

- Monitor feedback on owned products sold at Target.
- Detect recurring quality, fit, packaging, or value complaints.
- Compare launch sentiment before and after merchandising changes.

**Consumer-insights and research teams**

- Export review text for sentiment, topic, and language analysis.
- Compare rating distributions across competing product cohorts.
- Study verified-purchase feedback separately from other reviews.

**Product and quality teams**

- Route one-star reviews into issue-tracking or alert workflows.
- Track secondary ratings such as comfort, quality, or value.
- Build evidence for product iteration and supplier discussions.

**Data engineers and agencies**

- Schedule repeatable review collection through Apify.
- Deliver typed JSON or CSV to warehouses and dashboards.
- Trigger webhooks whenever a monitoring run finishes.

### Why use this Target reviews extractor?

- **Full pagination:** collect beyond the small initial set embedded in a product page.
- **No login:** use only anonymous public Target product-review surfaces.
- **Flexible product input:** mix normal Target URLs, short `/A-TCIN` links, and TCINs.
- **Useful filters:** select star rating, verified purchases, photo reviews, and sort order.
- **Monitoring-ready:** every row includes stable review and product identifiers plus timestamps.
- **CSV-friendly:** changing secondary dimensions are flattened into readable text.
- **Resilient HTTP:** requests run directly first, with bounded US residential fallback only after blocking.
- **Apify-native:** schedule runs, export datasets, call an API, and connect integrations without managing servers.

### What Target review data can you extract?

| Category | Fields |
|---|---|
| Product | `tcin`, `productTitle`, `productBrand`, `productUrl`, `productImageUrl`, `productCategory` |
| Review identity | `reviewId`, `externalReviewId`, `sourceChannel` |
| Review content | `reviewTitle`, `reviewText`, `rating`, `ratingRange`, `submittedAt`, `modifiedAt` |
| Reviewer | `authorNickname`, `authorId` |
| Trust signals | `isVerifiedPurchase`, `isRecommended`, `isIncentivized`, `isSyndicated`, `isRatingsOnly` |
| Engagement | `helpfulCount`, `unhelpfulCount`, `inappropriateCount` |
| Media and dimensions | `photoUrls`, `videoUrls`, `badges`, `secondaryRatings` |
| Product totals | aggregate average, rating count, written-review count, recommendation count/percentage, 1–5 star counts |
| Monitoring | `scrapedAt` |

Fields that Target does not expose for a particular product or review are omitted.
Boolean and count fields remain typed for filtering and downstream analysis.

### How much does it cost to scrape Target product reviews?

This Actor uses **pay-per-event pricing**.
A run has a $0.005 start charge, then charges per review saved.
Platform compute and proxy use are included.

| Apify plan | Price per review | 1,000 reviews plus start |
|---|---:|---:|
| Free | $0.000047483 | about $0.05 |
| Starter / Bronze | $0.00004129 | about $0.05 |
| Scale / Silver | $0.000032206 | about $0.04 |
| Business / Gold | $0.000024774 | about $0.03 |
| Platinum | $0.000016516 | about $0.02 |
| Diamond | $0.000011561 | about $0.02 |

A small 10-review test costs about $0.01 on the Free tier.
Apify's free platform credit can cover many small validation runs before you scale.
Always start with one product and a low review limit.

### How to scrape Target product reviews

1. Open Target Product Reviews Scraper in the Apify Store.
2. Paste one or more Target product URLs, or enter numeric TCINs.
3. Set **Maximum reviews per product** to a small value for the first run.
4. Optionally choose a star rating, verified-only, or photo-only filter.
5. Click **Start** and wait for the run to finish.
6. Open the dataset and export JSON, CSV, Excel, XML, RSS, or HTML.
7. Save the task and add a schedule if you want recurring monitoring.

A minimal input:

```json
{
  "productUrls": ["https://www.target.com/p/-/A-13521110"],
  "maxReviewsPerProduct": 10,
  "sort": "most_recent"
}
````

A verified-purchase export by TCIN:

```json
{
  "tcins": ["13521110"],
  "maxReviewsPerProduct": 100,
  "verifiedOnly": true,
  "sort": "most_recent"
}
```

A low-rating monitor:

```json
{
  "productUrls": [
    "https://www.target.com/p/-/A-13521110",
    "https://www.target.com/p/-/A-54551690"
  ],
  "maxReviewsPerProduct": 50,
  "ratingFilter": 1,
  "sort": "most_recent"
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `productUrls` | string\[] | prefilled sample | Target product URLs containing a TCIN |
| `tcins` | string\[] | empty | Numeric Target product IDs |
| `maxReviewsPerProduct` | integer | `100` | Maximum matching rows saved per unique product; range 1–5,000 |
| `sort` | string | `most_recent` | `most_recent`, `highest_rating`, `lowest_rating`, or `helpfulness_desc` |
| `ratingFilter` | integer | unset | Return only 1-, 2-, 3-, 4-, or 5-star reviews |
| `verifiedOnly` | boolean | `false` | Return only Target-verified purchases |
| `reviewsWithPhotosOnly` | boolean | `false` | Return only reviews with public customer photos |
| `includeRatingsOnly` | boolean | `true` | Keep star-only records when exposed |
| `maxRequestRetries` | integer | `3` | Bounded request attempts; range 1–6 |

At least one valid product URL or TCIN is needed to produce data.
Duplicates are processed once.

### Output example

```json
{
  "tcin": "13521110",
  "productTitle": "Microfiber Sheet Set - Room Essentials™",
  "productBrand": "Room Essentials",
  "productUrl": "https://www.target.com/p/microfiber-sheet-set-room-essentials/-/A-13521110",
  "reviewId": "195a9b24-f415-4640-9c1e-2373401bac37",
  "reviewTitle": "fits great",
  "reviewText": "purchased for college apt off campus. Fits great on the full bed.",
  "authorNickname": "just perfect",
  "rating": 5,
  "ratingRange": 5,
  "submittedAt": "2026-07-11T19:45:14.000+00:00",
  "isRecommended": true,
  "isVerifiedPurchase": true,
  "isIncentivized": false,
  "isSyndicated": false,
  "isRatingsOnly": false,
  "helpfulCount": 0,
  "unhelpfulCount": 0,
  "photoUrls": [],
  "videoUrls": [],
  "secondaryRatings": "comfort: 5/5; fit: true to size; quality: 5/5; value: 5/5",
  "aggregateAverageRating": 4.53,
  "aggregateRatingCount": 15582,
  "aggregateWrittenReviewCount": 4398,
  "aggregateRecommendedPercentage": 82,
  "scrapedAt": "2026-07-14T03:30:00.000Z"
}
```

The exact fields vary because reviewers may omit a nickname, title, text, recommendation,
secondary rating, or media.

### Sort and filter Target reviews

Use `most_recent` for launch monitoring and incremental feedback collection.
Use `helpfulness_desc` when researching the feedback other shoppers found most useful.
Use `highest_rating` or `lowest_rating` to inspect product strengths and weaknesses.

The star, verified-purchase, and photo filters are applied by Target's public review service.
This reduces transferred records and keeps the output focused.
The Actor continues pagination until it saves the requested number of matching rows
or Target reports the last available page.

### Tips for reliable review exports

- 🧪 Begin with 10 reviews from one known product.
- 🔢 Prefer TCINs when your catalog already stores Target product IDs.
- 🕐 Schedule recent-review runs daily or weekly rather than repeatedly collecting full history.
- ⭐ Use a star filter for complaint or advocacy workflows.
- ✅ Use `verifiedOnly` when your analysis requires stronger purchase evidence.
- 📷 Use photo-only filtering for user-generated-content research.
- 📉 Split very large product cohorts into tasks for easier retries and monitoring.
- 🔗 Keep `reviewId` as the deduplication key in your destination system.

### Review monitoring workflow

For recurring monitoring, save an Actor task with `sort: "most_recent"`.
Add a daily or weekly schedule,
then send finished dataset items to your warehouse or automation platform.
Deduplicate on `reviewId` and compare `submittedAt` with your last successful collection window.

For complaint alerts, use `ratingFilter: 1` or `2`.
A downstream automation can send product title, review text, verification status,
and canonical Target URL to Slack or an issue tracker.

### Integrations

**Target reviews → Google Sheets**

Export a product cohort into a worksheet for category managers and research teams.
Use `reviewId` as a stable key and refresh the sheet on a schedule.

**Target reviews → Slack or Discord**

Run a one-star monitor and post newly observed complaints with product context.

**Target reviews → Make or Zapier**

Trigger a sentiment-analysis step after each run,
then route negative topics to product or supplier owners.

**Target reviews → data warehouse**

Use a webhook after successful runs,
fetch dataset items through the API,
and load typed review rows into BigQuery, Snowflake, or PostgreSQL.

### Using the Apify API with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/target-product-reviews-scraper').call({
    tcins: ['13521110'],
    maxReviewsPerProduct: 25,
    sort: 'most_recent',
});

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

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/target-product-reviews-scraper').call(run_input={
    'productUrls': ['https://www.target.com/p/-/A-13521110'],
    'maxReviewsPerProduct': 25,
    'verifiedOnly': True,
})

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

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~target-product-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "tcins": ["13521110"],
    "maxReviewsPerProduct": 25,
    "sort": "most_recent"
  }'
```

After the run succeeds, use its `defaultDatasetId` to download items from the dataset API.

### Use Target reviews with AI agents via MCP

Target Product Reviews Scraper can be called by AI assistants through
[Apify's Model Context Protocol integration](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/target-product-reviews-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/target-product-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Use `automation-lab/target-product-reviews-scraper` to export the 50 newest reviews for Target TCIN 13521110."
- "Collect verified one-star reviews from these Target product URLs and summarize recurring quality complaints."
- "Monitor this Target product cohort weekly and prepare a table of new reviews, recommendation status, and helpful votes."

Your MCP client authenticates with Apify and receives normal Actor run and dataset links.

### Is it legal to scrape Target product reviews?

This Actor extracts information publicly visible without a Target login.
Public availability does not remove every legal or contractual obligation.
Use the data for legitimate purposes,
respect Target's terms and applicable rate limits,
and avoid collecting more personal data than your workflow needs.

Review text may be user-generated content.
Do not republish it in a misleading way,
profile reviewers,
or use public reviewer identifiers for unsolicited contact.
If your organization handles personal data,
apply relevant privacy, retention, and data-subject procedures such as GDPR or CCPA requirements.
Seek legal advice for your specific use case.

### Limitations

- Target can change its product page or public review service without notice.
- Some reviews do not contain a title, text, nickname, recommendation, or secondary scores.
- Product context enrichment can be absent while complete review rows still succeed.
- Ratings-only records may not include written feedback.
- Target may syndicate reviews from another source; inspect `isSyndicated` when provenance matters.
- Deleted, moderated, or newly submitted reviews can change totals between runs.
- The Actor accepts product URLs and TCINs, not Target search queries. Use Target Scraper to discover products first.

### Troubleshooting

**Why did my run return no reviews?**

Check that the URL contains a numeric `A-` TCIN or provide the TCIN directly.
The chosen star, verified, or photo filter may also have no matching reviews.
Test the same product without filters and with a limit of 10.

**Why is `productTitle` missing?**

Target's product-page context request can occasionally be blocked while the review endpoint remains available.
The row still includes the TCIN and stable Target URL,
and review extraction continues by design.

**Why are there fewer rows than `maxReviewsPerProduct`?**

The limit is a maximum, not a promise.
Target may expose fewer matching public records after filters,
or the review feed may reach its last page.

### FAQ

**Does the Actor require a Target account or API key?**

No. It uses anonymous public Target product and review surfaces.

**How fast is it?**

Small one-product exports usually finish quickly because the primary route is direct HTTP.
Runtime grows with products, pages, filters, and temporary retry needs.

**Can it retrieve all historical reviews?**

Set `maxReviewsPerProduct` up to 5,000.
The Actor paginates until that maximum or Target's last available matching page.

**How are duplicate reviews handled?**

The Actor deduplicates on Target's public review ID across every input in the same run.
Deduplicate again on `reviewId` when combining scheduled runs.

**Is this the same as Target Scraper?**

No. Target Scraper discovers products and returns search-result product details and aggregate counts.
This Actor returns the individual customer-review records for known products.

**Can I export to CSV or Excel?**

Yes. Open the run dataset and select CSV or Excel,
or request the format through the Apify dataset API.

### Other ecommerce and review scrapers

- [Target Scraper](https://apify.com/automation-lab/target-scraper) — discover Target products, prices, images, ratings, and counts.
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper) — collect individual Walmart customer reviews.
- [Walmart Scraper](https://apify.com/automation-lab/walmart-scraper) — discover Walmart product records.
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — export Amazon product feedback.
- [Best Buy Reviews Scraper](https://apify.com/automation-lab/best-buy-reviews-scraper) — collect electronics retailer reviews.
- [Ulta Product Reviews Scraper](https://apify.com/automation-lab/ulta-product-reviews-scraper) — analyze beauty-product feedback.
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) — export location and business reviews.

Combine Target Scraper for product discovery with Target Product Reviews Scraper for review depth.

# Actor input Schema

## `productUrls` (type: `array`):

Add one or more Target product URLs. Standard product links and short /p/-/A-TCIN links are supported.

## `tcins` (type: `array`):

Add Target product IDs directly, for example 13521110.

## `maxReviewsPerProduct` (type: `integer`):

Set the maximum number of matching review rows to save for each product.

## `sort` (type: `string`):

Choose Target's order for paginated reviews.

## `ratingFilter` (type: `integer`):

Optionally return only reviews with one selected star rating.

## `verifiedOnly` (type: `boolean`):

Enable to return only reviews Target marks as verified purchases.

## `reviewsWithPhotosOnly` (type: `boolean`):

Enable to return only review records that include customer photos.

## `includeRatingsOnly` (type: `boolean`):

Keep star-only review records when Target exposes them.

## `maxRequestRetries` (type: `integer`):

Set bounded attempts for temporary Target blocks or network failures.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.target.com/p/-/A-13521110"
  ],
  "tcins": [],
  "maxReviewsPerProduct": 10,
  "sort": "most_recent",
  "verifiedOnly": false,
  "reviewsWithPhotosOnly": false,
  "includeRatingsOnly": true,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

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

No description

# 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 = {
    "productUrls": [
        "https://www.target.com/p/-/A-13521110"
    ],
    "tcins": [],
    "maxReviewsPerProduct": 10,
    "sort": "most_recent",
    "verifiedOnly": false,
    "reviewsWithPhotosOnly": false,
    "includeRatingsOnly": true,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/target-product-reviews-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 = {
    "productUrls": ["https://www.target.com/p/-/A-13521110"],
    "tcins": [],
    "maxReviewsPerProduct": 10,
    "sort": "most_recent",
    "verifiedOnly": False,
    "reviewsWithPhotosOnly": False,
    "includeRatingsOnly": True,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/target-product-reviews-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 '{
  "productUrls": [
    "https://www.target.com/p/-/A-13521110"
  ],
  "tcins": [],
  "maxReviewsPerProduct": 10,
  "sort": "most_recent",
  "verifiedOnly": false,
  "reviewsWithPhotosOnly": false,
  "includeRatingsOnly": true,
  "maxRequestRetries": 3
}' |
apify call automation-lab/target-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Target Product Reviews Scraper",
        "description": "Extract public Target reviews, ratings, text, authors, verified-purchase signals, helpfulness, customer media, secondary scores, and product rating totals. Export JSON, CSV, or Excel and schedule recurring monitoring.",
        "version": "0.1",
        "x-build-id": "uw7pcU9kWfh66AvuD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~target-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-target-product-reviews-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/automation-lab~target-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-target-product-reviews-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/automation-lab~target-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-target-product-reviews-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": {
                    "productUrls": {
                        "title": "🎯 Target product URLs",
                        "type": "array",
                        "description": "Add one or more Target product URLs. Standard product links and short /p/-/A-TCIN links are supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "tcins": {
                        "title": "Numeric TCINs",
                        "type": "array",
                        "description": "Add Target product IDs directly, for example 13521110.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Set the maximum number of matching review rows to save for each product.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort reviews",
                        "enum": [
                            "most_recent",
                            "highest_rating",
                            "lowest_rating",
                            "helpfulness_desc"
                        ],
                        "type": "string",
                        "description": "Choose Target's order for paginated reviews.",
                        "default": "most_recent"
                    },
                    "ratingFilter": {
                        "title": "Star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Optionally return only reviews with one selected star rating."
                    },
                    "verifiedOnly": {
                        "title": "Verified purchases only",
                        "type": "boolean",
                        "description": "Enable to return only reviews Target marks as verified purchases.",
                        "default": false
                    },
                    "reviewsWithPhotosOnly": {
                        "title": "Reviews with photos only",
                        "type": "boolean",
                        "description": "Enable to return only review records that include customer photos.",
                        "default": false
                    },
                    "includeRatingsOnly": {
                        "title": "Include ratings without text",
                        "type": "boolean",
                        "description": "Keep star-only review records when Target exposes them.",
                        "default": true
                    },
                    "maxRequestRetries": {
                        "title": "Maximum request attempts",
                        "minimum": 1,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Set bounded attempts for temporary Target blocks or network failures.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```