# Target Reviews Scraper — Export to CSV (`fetch_cat/target-reviews-scraper`) Actor

Export public Target product reviews, ratings, dates, and recommendation signals from URLs or TCINs. Download CSV, Excel, or JSON, or use the API.

- **URL**: https://apify.com/fetch\_cat/target-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 94.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 review saveds

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/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Reviews Scraper — Export to CSV

Export public Target product reviews to CSV, Excel, JSON, or the Apify API. Enter Target product URLs or TCIN item IDs to collect review text, star ratings, dates, recommendation signals, and product-level rating summaries.

No Target login or cookies are required.

Each dataset row is one review, with its product context attached. Use the data to investigate customer complaints, compare product feedback, or prepare a review dataset for analysis.

**Before you start:** `maxReviews` is a total limit across the run—not a limit per product. Sorting by lowest rating does not filter exclusively for one-star reviews. Optional fields can be `null` when Target does not supply them.

### Try a small Target review export

Open the Actor, switch to JSON input, and start with one product and an explicit review limit:

```json
{
  "tcins": ["85978622"],
  "maxReviews": 20,
  "sortBy": "most_recent",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

Replace the TCIN with your product's item ID. You can find it in a Target product URL after `A-`. Product availability and review counts can change.

After the run, open the dataset and export your results as CSV, Excel, or JSON. For a partial or failed run, also inspect `RUN_SUMMARY` in key-value storage.

#### What one review looks like

This is an illustrative excerpt, not a fresh review or a live product-rating claim. The full field list appears below.

```json
{
  "tcin": "85978622",
  "productUrl": "https://www.target.com/p/-/A-85978622",
  "productTitle": "Example product",
  "reviewId": "example-review-id",
  "reviewTitle": "Comfortable for everyday use",
  "reviewText": "The fit worked well for me.",
  "rating": 4,
  "submittedAt": "2026-07-01",
  "verifiedPurchaser": null,
  "averageRating": 4.3,
  "reviewCount": 120,
  "scrapedAt": "2026-08-31T09:00:00.000Z"
}
```

`rating` describes this review. `averageRating` and `reviewCount` describe the product's public summary; they are not calculated from the sample you export.

### Ready-to-run examples

These public examples let you inspect and reuse a saved input:

- [Monitor Target Product Feedback](https://apify.com/fetch_cat/target-reviews-scraper/examples/monitor-target-product-feedback) — start with recent reviews for repeat monitoring.
- [Find Lowest Rated Target Product Reviews](https://apify.com/fetch_cat/target-reviews-scraper/examples/find-lowest-rated-target-product-reviews) — investigate complaints before filtering the exported ratings.
- [Find Highest Rated Target Product Reviews](https://apify.com/fetch_cat/target-reviews-scraper/examples/find-highest-rated-target-product-reviews) — examine positive feedback.
- [Scrape Target Reviews By Tcin](https://apify.com/fetch_cat/target-reviews-scraper/examples/scrape-target-reviews-by-tcin) — use item IDs instead of full URLs.
- [Scrape Recent Target Airpods Reviews](https://apify.com/fetch_cat/target-reviews-scraper/examples/scrape-recent-target-airpods-reviews) — inspect a single-product example.
- [Build Ai Dataset From Target Reviews](https://apify.com/fetch_cat/target-reviews-scraper/examples/build-ai-dataset-from-target-reviews) — collect review text for downstream analysis.

[View all ready-to-run examples](https://apify.com/fetch_cat/target-reviews-scraper/examples).

### What can you do with Target review data?

- **Investigate product complaints:** request `lowest_rating`, then group review text by recurring issues in your own analysis tool.
- **Monitor recent feedback:** schedule runs with `most_recent` and compare `tcin` plus `reviewId` across datasets to identify newly collected reviews.
- **Compare competing products:** keep product IDs and product summary fields beside each review. For equal-sized samples, run each product separately with the same limit and sort.
- **Prepare AI analysis:** pass review text, ratings, and product IDs to your analysis workflow. The Actor exports data; it does not perform sentiment analysis or generate summaries itself.

### Input settings

Provide at least one product URL or TCIN. If both are supplied, duplicate TCINs are combined.

| Setting / JSON key | Accepted input | What to know |
| --- | --- | --- |
| Target product URLs / `startUrls` | Array of objects with `url` | Public HTTPS Target product URLs containing `A-` followed by the 6–12 digit TCIN. |
| Target item IDs / `tcins` | Array of strings | TCINs only, for example `["85978622"]`. Do not put product URLs here. |
| Maximum reviews / `maxReviews` | Integer, 1–10,000 | Total across all products. Set it explicitly in automated runs. The input form suggests 20. |
| Review order / `sortBy` | `most_recent`, `highest_rating`, `lowest_rating` | Controls ordering, not an exact star-rating filter. Default: `most_recent`. |
| Connection settings / `proxyConfiguration` | Apify proxy configuration object | The input form defaults to residential Apify Proxy. The example above includes it explicitly. |

URL input works too:

```json
{
  "startUrls": [{"url": "https://www.target.com/p/-/A-85978622"}],
  "maxReviews": 20,
  "sortBy": "lowest_rating",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

Products are processed in sequence. An earlier product can use the entire review limit before later products are reached.

### Output fields

Missing optional values are `null`; missing is not the same as zero or false.

#### Review-level data

| Field | Meaning |
| --- | --- |
| `reviewId` | Review identifier; combine with `tcin` when comparing exports. |
| `reviewTitle`, `reviewText` | Review heading and body text, when supplied. |
| `rating` | Star rating attached to the individual review. |
| `authorNickname` | Public reviewer display name, not contact information. |
| `submittedAt` | Review submission date supplied by Target. |
| `isRecommended` | Whether the reviewer recommends the product, when supplied. |
| `helpfulVotes`, `notHelpfulVotes` | Counts of helpful and unhelpful feedback votes. |
| `verifiedPurchaser` | Target's verified-purchaser flag, when available. |
| `isSyndicated` | Whether Target identifies the review as syndicated. |
| `dataSourceName` | Review source name supplied by Target. |
| `sortBy` | Sort order requested for this run. |
| `scrapedAt` | Extraction timestamp for the run, not the review's posting date. |

#### Product context repeated on each review

| Field | Meaning |
| --- | --- |
| `productUrl`, `tcin` | Target product URL and item identifier. |
| `productTitle`, `brand` | Product name and brand when available. |
| `averageRating` | Product's aggregate rating supplied by Target. |
| `ratingCount` | Count of ratings in the product summary. |
| `reviewCount` | Count of reviews in the product summary; can differ from the ratings count. |
| `recommendedCount`, `notRecommendedCount` | Product-level counts of recommendation responses. |
| `recommendedPercentage` | Product-level recommendation percentage supplied by Target. |

There are no separate product-summary dataset rows. Avoid summing repeated product totals across review rows.

### Pricing

The Actor uses pay-per-event pricing:

- **`start`:** one charge when a run passes the product-input checks and begins processing. A valid run can incur this charge even if no reviews are returned.
- **`item`:** charged per Target review extracted. Product summaries are included on review rows, not sold as separate result rows.

See the [live Pricing tab](https://apify.com/fetch_cat/target-reviews-scraper/pricing) for current rates and any discounts available to your account. Check the run's cost details for the charges applied to that run.

Control the size of an export with `maxReviews`. A scheduled run is a new extraction; the Actor does not maintain a history of reviews already collected by previous runs.

### Tips, limitations, and partial results

- **Public reviews only:** no Target account credentials are required. This does not provide private customer records or purchase histories.
- **Fewer results are possible:** the requested limit is a ceiling, not a guarantee. Availability, Target access restrictions, and the run deadline can limit collection.
- **Not a star filter:** for one-star reviews, use `lowest_rating` and then filter exported rows where `rating` equals `1`. This is not a guarantee of collecting every one-star review.
- **Check failed products:** `RUN_SUMMARY` can identify skipped TCINs and failure reasons. A run with no extracted reviews is marked failed; previously saved data can still be useful after a partial interruption.
- **Continue carefully:** when processing stops near the deadline, `PENDING_TCINS` may contain products to retry. Supply those IDs in a new run; retries can repeat reviews from a partially processed product.
- **Do not infer missing data:** a `null` verified-purchaser flag does not prove an unverified purchase. A missing recommendation percentage does not mean zero recommendations.

### Run through the Apify API

Install `apify-client` for Node.js or `apify-client` for Python, and set `APIFY_TOKEN` securely in your environment. These examples start a paid Actor run under your account's pricing.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/target-reviews-scraper').call({
  tcins: ['85978622'],
  maxReviews: 20,
  sortBy: 'most_recent',
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL']
  }
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/target-reviews-scraper').call(run_input={
    'tcins': ['85978622'],
    'maxReviews': 20,
    'sortBy': 'most_recent',
    'proxyConfiguration': {
        'useApifyProxy': True,
        'apifyProxyGroups': ['RESIDENTIAL']
    }
})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

#### cURL

```bash
curl --fail-with-body -X POST \
  'https://api.apify.com/v2/acts/fetch_cat~target-reviews-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"tcins":["85978622"],"maxReviews":20,"sortBy":"most_recent","proxyConfiguration":{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}}'
```

The cURL request starts an asynchronous run and returns run metadata, not review rows. Wait for completion before reading its default dataset. For larger exports, paginate dataset retrieval. See the [Actor API tab](https://apify.com/fetch_cat/target-reviews-scraper/api).

### Use with AI agents through MCP

Use the official hosted Apify MCP server; this Actor does not run its own MCP server.

For Claude Code:

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

For a client that accepts remote HTTP servers in `mcpServers` configuration:

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

Authorize access to your Apify account when prompted. Client setup formats differ; use the [official Apify MCP setup guide](https://docs.apify.com/integrations/mcp) for your client.

The focused URL exposes this Actor. The general server at `https://mcp.apify.com` also provides Actor discovery tools. Connecting a tool is separate from having its page appear in an AI search answer.

Example prompts:

- "Collect up to 20 recent reviews for Target TCIN 85978622. Group complaints by theme and include the source review IDs."
- "Fetch up to 30 reviews sorted by lowest rating, then show only rows rated one star. Tell me if the sample is smaller than requested."
- "Compare these two saved datasets by TCIN and review ID. Separate newly collected reviews from reviews seen in both exports."

### FAQ

#### Can I download Target reviews to CSV or Excel?

Yes. Export the dataset after the run, or retrieve rows through the Apify API.

#### Is this a Target reviews API alternative?

It provides API access to extracted public Target reviews through Apify. It is not Target's official API and does not grant access to private or partner-only data.

#### Can I get 20 reviews from each of several products?

`maxReviews` applies to the whole run. Use a separate run per product with `maxReviews: 20` when you need separate per-product limits; each run has its own start charge.

#### Can I track new reviews automatically?

Schedule the Actor in Apify and compare successive exports in your own workflow. Use `tcin` and `reviewId` to identify repeats; scheduling alone does not create an incremental-only export or an alerting service.

#### Does it perform sentiment analysis?

No. It exports review data. You can analyze the text downstream, preserving product and review identifiers for traceability.

### Related Actors

- [AliExpress Reviews Scraper](https://apify.com/fetch_cat/aliexpress-reviews-scraper) — collect customer feedback from another retail marketplace.
- [Walmart Products Scraper](https://apify.com/fetch_cat/walmart-products-scraper) — add product research from a neighboring retail channel.
- [Shopify Products Scraper](https://apify.com/fetch_cat/shopify-products-scraper) — export public storefront catalogs for product comparisons.
- [Ecommerce Product Page Scraper](https://apify.com/fetch_cat/ecommerce-product-page-scraper) — collect product-page details for a broader research workflow.
- [Google Shopping Results Scraper](https://apify.com/fetch_cat/google-shopping-results-scraper) — complement review research with shopping-result data.

### Support

Report failed runs, wrong output, or missing fields through the [Issues tab](https://apify.com/fetch_cat/target-reviews-scraper/issues). Include the run ID or run URL, input JSON with secrets removed, expected output, actual output, and one reproducible public product URL or TCIN. Add the relevant `RUN_SUMMARY` details if a product was skipped.

### Privacy and data handling

This Actor runs with Apify limited permissions and only processes data needed for the documented run. It uses review lookup inputs and public review results to produce the output dataset and sends requests to public Target Reviews pages/endpoints; results are stored in Apify run storage for your account. FetchCat does not use your inputs or outputs for advertising, does not use them for model training, and does not retain them outside the Apify run except for transient support debugging when you explicitly share run details. You are responsible for using the Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs.

# Actor input Schema

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

Paste one or more Target product URLs. URLs containing /A-12345678 are supported.

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

Optional Target item IDs (TCINs), for example 85978622. Use this when you already have item IDs instead of URLs.

## `maxReviews` (type: `integer`):

Maximum number of review rows to save across all products.

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

Order used when requesting Target reviews.

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

Apify Proxy settings. The default uses residential proxy because Target commonly rate-limits direct datacenter requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ],
  "tcins": [],
  "maxReviews": 20,
  "sortBy": "most_recent",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/target-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 = { "startUrls": [{ "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622" }] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/target-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.target.com/p/apple-airpods-pro-2nd-generation-with-magsafe-case-usb-c/-/A-85978622"
    }
  ]
}' |
apify call fetch_cat/target-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/target-reviews-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/AWXG6hQyeCXrbvPN9/builds/V6xRqYYb9VAI7c7T0/openapi.json