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

Collects Target.com product data — prices, sale status, ratings, reviews, and full product details — from search queries or Target URLs. Returns structured records with optional product details and customer reviews.

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

## Pricing

from $0.97 / 1,000 products

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/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.com Product Scraper** collects product records from Target.com — prices, sale status, ratings, reviews, and full product details — and turns them into structured data for price monitoring, competitive research, and catalog building. Enter a search term or a Target URL, run the Actor, and export product records to JSON, CSV, Excel, or your own integration. Use it for daily price tracking, brand and category research, and recurring deal monitoring. Pay per event: $1 per 1,000 products, with optional details and reviews billed separately.

### What can you automate with Target.com Product Scraper?

- **Build a product catalog** — turn any search term, category, brand, or weekly-ad page into clean, structured product records.
- **Monitor prices and deals** — capture current price, regular price, and sale status (`isOnSale`) to spot discounts as they appear.
- **Track ratings and reviews** — collect average rating and review counts, then enrich with full review text and statistics when enabled.
- **Enrich listings automatically** — add descriptions, specifications, highlights, variants, barcode, and DPCI with the product-details toggle.
- **Pull weekly-ad promotions** — point the Actor at a specific store's weekly ad to capture promoted items.
- **Export anywhere** — download results as JSON, CSV, or Excel, or stream them through the Apify API.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Price-monitoring teams | Track Target prices and sale flags daily to stay competitive |
| Market researchers | Analyze assortments, brands, and pricing across searches and departments |
| E-commerce catalog builders | Build product databases with titles, images, prices, and identifiers |
| Review analysts | Collect customer reviews and rating statistics for sentiment work |

### What data can you collect from Target.com?

| Data group | Example fields | How it helps |
|---|---|---|
| Product identity | `title`, `brand`, `tcin`, `url`, `dpci` | Match and deduplicate products by their Target catalog ID |
| Price & availability | `price`, `formattedPrice`, `regularPrice`, `currency`, `isOnSale` | Spot current price, discounts, and sale status |
| Social proof | `rating`, `reviewCount`, `badges` | Gauge popularity and customer sentiment at a glance |
| Media & details | `imageUrl`, `highlights`, `specifications`, `variants`, `barcode` | Enrich listings with imagery, specs, and identifiers |
| Reviews | `reviews`, `reviewStatistics` | Capture review text and aggregate stats when enabled |

*Detail and review fields are only returned when the matching input toggle is enabled.*

### How to use Target.com Product Scraper

1. Open the Actor on Apify.
2. Enter a search term (for example "socks") in `searchQueries`, or paste a Target URL in `startUrls`.
3. Set `maxItems` and choose whether to enable product details or reviews.
4. Run the Actor.
5. Export the dataset to JSON, CSV, or Excel, or connect it to your workflow.

```json
{
    "searchQueries": ["socks"],
    "maxItems": 10,
    "includeProductDetails": false,
    "includeReviews": false
}
```

### Example workflow

#### Build a weekly price list for a tracked set of products

1. Run a search or category query every Monday for the brands you track.
2. Keep only records where `isOnSale` is true or the price changed since last week.
3. Send new or changed records to Google Sheets or your CRM.
4. Deduplicate using the stable `tcin` value.

### Automate and integrate your results

- **Schedules** — run daily for price monitoring or hourly for clearance and flash deals; keep `maxItems` bounded to control cost.
- **Webhooks** — trigger a webhook on run completion to update a database, spreadsheet, or notification pipeline automatically.
- **Integrations** — push results to Google Sheets, Make, Zapier, Slack, a CRM, or cloud storage, or call the Actor from the Apify API.
- **Deduplication** — each product is identified by its Target catalog item number `tcin`; deduplicate runs on `tcin` before ingesting.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---|---|---:|---|
| `searchQueries` | array | one of \* | — | Product search terms, e.g. "socks" |
| `startUrls` | array | one of \* | — | Target URLs: search, category, brand, product, deals, clearance, or weekly-ad pages |
| `maxItems` | integer | optional | 10 | Maximum products to collect (0 = unlimited) |
| `includeProductDetails` | boolean | optional | false | Fetch descriptions, specs, images, variants, barcode per product |
| `includeReviews` | boolean | optional | false | Fetch customer reviews per product |
| `maxReviews` | integer | optional | 10 | Max reviews per product when reviews are enabled (0 = all, capped at 200) |
| `detailConcurrency` | integer | optional | 5 | How many products to enrich in parallel (1–15) |
| `storeId` | string | optional | "3991" | Target store ID for local pricing and weekly ads |
| `zipCode` | string | optional | "55401" | US ZIP code for store-local pricing context |
| `proxyConfiguration` | object | optional | residential | Proxy settings for reliable Target access |

\* Provide at least one of `searchQueries` or `startUrls`.

#### What is the difference between `searchQueries` and `startUrls`?

`searchQueries` is the simplest way to start — type a term and it runs as a Target search. `startUrls` accepts full Target.com URLs so you can target a specific search, category, brand, product, deals, clearance, or weekly-ad page. You can combine both in one run.

#### What are `storeId` and `zipCode` for?

They control store-local pricing and availability context. The default `storeId` of "3991" targets the online catalog; a specific store ID returns that store's local prices and its weekly ad. `zipCode` is sent with product requests for local pricing context.

### Output example

```json
{
    "tcin": "14073500",
    "url": "https://www.target.com/p/hanes-men-39-s-ankle-socks-with-freshiq-8pk-white-6-12/-/A-14073500",
    "title": "Hanes Men's Ankle Socks with FreshIQ 8pk - White 6-12",
    "brand": "Hanes",
    "price": 10.0,
    "regularPrice": 14.0,
    "formattedPrice": "$10.00",
    "currency": "USD",
    "isOnSale": true,
    "rating": 4.25,
    "reviewCount": 780,
    "imageUrl": "https://target.scene7.com/is/image/Target/GUEST_a6e47d94-b48d-4448-87d7-c2d2fdadf0eb",
    "badges": ["Trending"],
    "dpci": "040-11-0190",
    "reviews": [
        {
            "title": "great cushion socks.",
            "text": "my husband loves the socks.",
            "rating": 5.0,
            "author": "Vunserpenk",
            "isVerified": true
        }
    ],
    "reviewStatistics": {
        "reviewCount": 233,
        "averageRating": 4.16,
        "recommendedPercentage": 54.0
    }
}
```

### How much does it cost to scrape Target.com?

The Actor uses pay-per-event billing, so you pay only for the data you receive:

- **$1 per 1,000 products** — charged as a `dataset-item` event for every product saved to the dataset.
- **$1 per 1,000 product details** — charged as a `product-details` event, only when `includeProductDetails` is enabled.
- **$1 per 1,000 reviews** — charged as a `product-reviews` event, only when `includeReviews` is enabled.

A run also charges a one-time $0.00005 actor-start event. Scraping 1,000 products with both details and reviews costs about $3 before plan discounts. Higher Apify plans (Bronze, Silver, Gold) apply discounted per-event rates, down to roughly $0.97 per 1,000 events.

### Reliability and responsible use

- **Proxy** — a US residential proxy is recommended for reliable Target access; the default configuration enables Apify Residential.
- **Enrichment controls** — product details and reviews are only collected when their toggles are enabled, keeping runs fast and cheap.
- **Conditional fields** — detail fields (descriptions, specs, variants, barcode) and review fields are empty unless the matching toggle is on.
- **Public data** — the Actor collects publicly listed product and review information.
- **Lawful use** — you are responsible for using collected data in line with Target's terms and applicable laws.

### Frequently asked questions

#### Can I scrape product reviews from Target.com?

Yes. Enable `includeReviews` to collect customer reviews for each product, and set `maxReviews` to control how many per product (default 10, up to a hard cap of 200).

#### Can I schedule Target.com Product Scraper to run automatically?

Yes. Use the Scheduler tab in Apify Console to run daily, hourly, or per search query, and set up webhooks to push fresh data into your pipeline.

#### What counts as one result?

Every product saved to the dataset bills one `dataset-item` event. Enabling details or reviews adds a `product-details` or `product-reviews` event per product.

#### Why are some fields empty?

Fields like `highlights`, `specifications`, `variants`, `barcode`, and `reviews` only appear when `includeProductDetails` or `includeReviews` is enabled. Ratings and images can also be absent for products that don't publish them.

#### How do I avoid duplicate records?

Deduplicate by the `tcin` (Target catalog item number), which is stable across runs. You can also cap output with `maxItems`.

#### Do I need a proxy?

Target may block requests without one. Keep the default Apify Residential (US) proxy enabled in `proxyConfiguration` for reliable results.

### Related Scraptivo automations

- **[Amazon Product Scraper](https://apify.com/scraptivo/amazon-product-scraper)** — collect Amazon product data, prices, and seller details.
- **[Amazon Search Scraper](https://apify.com/scraptivo/amazon-scraper)** — extract Amazon search results by query.
- **[Costco Product Scraper](https://apify.com/scraptivo/costco-scraper)** — collect Costco products, prices, ratings, and availability.
- **[HomeDepot Scraper](https://apify.com/scraptivo/homedepot-scraper)** — extract HomeDepot product data by collection URL and ZIP code.
- **[Publix Scraper](https://apify.com/scraptivo/publix-scraper)** — collect Publix product and store data.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, a sample URL, the required fields, and expected volume so we can assess the request.

# Actor input Schema

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

Product search terms to look up on Target.com (e.g. "socks", "tide pods", "lego star wars"). Primary input for AI agents — no URL required. Combine with Start URLs if you want both.

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

Target.com URLs to scrape instead of or in addition to search queries (e.g. "https://www.target.com/s?searchTerm=socks", "https://www.target.com/c/toys-clearance/-/N-5tg3d", "https://www.target.com/p/-/A-14073530", "https://www.target.com/weekly-ad"). Accepts search, category, deals, clearance, product, brand, and weekly-ad pages.

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

Maximum number of products to scrape across all queries and URLs (0 = unlimited).

## `includeProductDetails` (type: `boolean`):

When enabled, fetch the full product page for each item (description, specifications, extra images, variants, barcode). Charged as the product-details event in addition to each dataset item.

## `includeReviews` (type: `boolean`):

When enabled, fetch customer reviews for each product. Charged as the product-reviews event in addition to each dataset item.

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

Maximum number of reviews to collect per product when Include Product Reviews is enabled (0 = all, capped internally).

## `detailConcurrency` (type: `integer`):

How many products to enrich in parallel (product details and reviews run at the same time per product). Each worker uses its own proxy session and rotates it periodically. Higher is faster; keep it modest to avoid blocks.

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

Target store ID used for local pricing and weekly ads (e.g. "3991" for the online catalog, "1532" for a specific store). Leave the default unless you need a particular store's prices.

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

US ZIP code sent with listing and product requests (e.g. "55401", "10001"). Used for store-local pricing context.

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

Proxy settings. Apify Residential (US) is recommended for reliable Target access.

## Actor input object example

```json
{
  "searchQueries": [
    "socks"
  ],
  "startUrls": [
    {
      "url": "https://www.target.com/s?searchTerm=socks"
    }
  ],
  "maxItems": 10,
  "includeProductDetails": false,
  "includeReviews": false,
  "maxReviews": 10,
  "detailConcurrency": 5,
  "storeId": "3991",
  "zipCode": "55401",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of scraped Target products

## `runStats` (type: `string`):

Record count and timestamps for this run

# 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": [
        "socks"
    ],
    "startUrls": [
        {
            "url": "https://www.target.com/s?searchTerm=socks"
        }
    ],
    "maxItems": 10,
    "maxReviews": 10,
    "detailConcurrency": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/target-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["socks"],
    "startUrls": [{ "url": "https://www.target.com/s?searchTerm=socks" }],
    "maxItems": 10,
    "maxReviews": 10,
    "detailConcurrency": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/target-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 '{
  "searchQueries": [
    "socks"
  ],
  "startUrls": [
    {
      "url": "https://www.target.com/s?searchTerm=socks"
    }
  ],
  "maxItems": 10,
  "maxReviews": 10,
  "detailConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/target-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraptivo/target-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/pT6hkrSSpEQ4b9kZI/builds/DcbwqcNERJdoJZnrm/openapi.json