Target Products Scraper — Prices, Stock, Images & UPC

For e-commerce analysts tracking Target.com prices, dropshippers building catalogs, and data teams that need product images that actually populate — not the empty [] arrays most Target scrapers ship.

Pricing: $0.0029 per product ($2.90/1,000 products) — one flat per-product rate. No proxy key, no API key, no add-on fees.

Scrape Target.com products by keyword search, category page, or direct product URL. Every product comes back as a flat JSON row with price, sale detection, full image set, UPC, rating and reviews — a real Target browser session on residential access is built in.

What you get per product

Field	Description
tcin	Target's internal product ID (TCIN)
title	Product title
brand	Brand name
price	Current price (USD)
regular_price	Regular (pre-sale) price
on_sale	true when current price is below regular — instant deal detection
rating	Average star rating
review_count	Number of customer reviews
primary_image	Main product image URL
alternate_images	Full image set — every scene7 image URL for the product (typically 15–21 images), where most scrapers return an empty list
availability	Stock / availability status
upc	UPC barcode when present in page-loaded data
description	Product description when present in page-loaded data
bullets	Bullet-point specs when present in page-loaded data
url	Canonical Target.com product URL
parse_confidence	Per-row quality score 0.0–1.0 — catch site changes before they break your pipeline
scraped_at	ISO 8601 run timestamp

Why this scraper

• Images that populate. The headline edge: a complete alternate_images set (real scene7 CDN URLs, ~15–21 per product) where competing Target scrapers ship []. If you build catalogs or feeds, this is the difference between usable and useless.
• Sale detection. on_sale plus regular_price vs price — find every markdown without diffing snapshots yourself.
• Page-owned data only. Each real Target listing page supplies its own product JSON; the actor does not issue separate per-product RedSky requests that trigger PerimeterX.
• Reliable access, no keys. Opens real Target pages through the buyer's Apify residential proxy and consumes only JSON those pages load themselves — no external proxy key or API key to configure.
• parse_confidence on every row — a quality signal no commodity Target scraper exposes.

Input

{
  "searchQueries": ["coffee maker", "airpods"],
  "urls": ["https://www.target.com/p/-/A-12345678"],
  "maxProductsPerSearch": 60,
  "fetchProductDetails": true,
  "storeId": "3991",
  "zipCode": "10001"
}

Parameter	Default	Description
searchQueries	—	Keywords to search on Target.com (one product list per query)
urls	—	Product, category, or search URLs (product data is returned only when the real page loads it; category/search are paginated)
maxProductsPerSearch	60	Max products per query/URL (0 = unlimited up to the page cap)
fetchProductDetails	true	Backwards-compatible input; no separate PDP request is made, and page-loaded fields are returned
storeId	blank	Target store number for price + in-store availability
zipCode	10001	US ZIP for delivery/pricing context
proxyConfiguration	RESIDENTIAL	Apify residential proxy (recommended — datacenter IPs are rate-limited by Target)

Pricing example

Run	Products	Cost
Trial (1 query, 60-cap default)	60	$0.17
1,000 products	1,000	$2.90
10,000 products	10,000	$29.00

Pay per result — you are charged once per product delivered to the dataset. Blocked or empty queries are not charged. The buyer's Apify account pays for proxy/platform compute.

Run status

Every run stores a RUN_STATUS key-value-store record for monitoring delivery and coverage:

• plpPagesFetched — product-listing pages fetched successfully.
• plpFetchErrors — product-listing page fetch errors.
• pdpFetched — direct product pages whose own detail response was captured.
• pdpSkipped — listing rows intentionally delivered without a separate PDP request.
• blockedRetriesExhausted — blocked requests whose retries were exhausted; use this to detect access issues.
• deliveredRecords — product records delivered to the dataset.
• coverageComplete — true when requested coverage is complete; false flags partial coverage.
• lastError — the latest recorded error, if any.

Output sample

{
  "tcin": "12345678",
  "title": "Keurig K-Classic Single Serve Coffee Maker",
  "brand": "Keurig",
  "price": 169.99,
  "regular_price": 219.99,
  "on_sale": true,
  "rating": 4.44,
  "review_count": 2012,
  "primary_image": "https://target.scene7.com/is/image/Target/GUEST_xxxx",
  "alternate_images": [
    "https://target.scene7.com/is/image/Target/GUEST_aaaa",
    "https://target.scene7.com/is/image/Target/GUEST_bbbb"
  ],
  "availability": "in_stock",
  "upc": "611247373767",
  "url": "https://www.target.com/p/-/A-12345678",
  "parse_confidence": 1.0,
  "scraped_at": "2026-06-14T10:00:00+00:00"
}

Use cases

• Price & promo monitoring — track Target prices and catch every on_sale markdown.
• Catalog / feed building — full image sets + specs + UPC ready to drop into a storefront or marketplace feed.
• Competitive intelligence — brand, rating and review-count benchmarking across a category.
• Dropshipping — product data with real images, no manual copy-paste.

FAQ

Do I need an API key or proxy key? No. Target's public web key is built in. The actor uses the standard Apify residential proxy from your run configuration; no external proxy credential is required.

Why are images better here? The actor extracts every scene7 image entry present in Target's page-loaded product payload instead of dropping the gallery array during normalization.

What formats can I export? JSON, CSV, Excel, or JSONL — from the Apify dataset UI or REST API.

What if a product is out of stock? It is still returned with availability reflecting its status; rating/review_count may be empty for products with no reviews (real data, not a parse miss).

Integrations

Built for e-commerce analysts, dropshippers, and catalog teams extracting Target.com product data with prices, images and UPC — the JSON/dataset output drops into the tools you already run, no glue code:

• n8n / Make / Zapier — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, your database) with no code: n8n, Make, Zapier.
• Webhooks — fire your own endpoint the moment a run finishes (docs).
• MCP server — expose this actor as a tool to Claude, Cursor, or any MCP client so an AI agent can pull Target product data mid-conversation (guide).
• API & SDKs — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all Apify integrations.

Legal & compliance

This actor collects only publicly visible Target.com product data — the same information any visitor sees while browsing the site without logging in. It does not access private or authenticated content and stores no personal data. Use it in accordance with Target's Terms of Service and applicable regulations; the operator is responsible for ensuring their use case complies. Not affiliated with or endorsed by Target Brands, Inc.

Usage statistics

This Actor creates a small, content-free summary at the end of each run. It is used only to monitor reliability and improve this Actor. A copy is saved as USAGE_STATS in your own Apify key-value store, so you can see the exact record created for your run.

Set disableUsageStats to true in the input to opt out. Nothing is sent then; your USAGE_STATS record only says that statistics were disabled.

Only these fields are recorded:

• schema version, Actor name and build number;
• UTC start and finish hour (not a precise timestamp);
• run duration, number of results and time to the first result, each as a coarse range;
• whether the result was empty, the end status, and an error type from a fixed list;
• memory setting and counts of charged events;
• names of the input fields you set, never their values;
• the selected option for input fields that offer a fixed list of choices (for example a sort order).

We do not collect input text, search terms, URLs, domains, usernames, email addresses, names, proxy credentials, tokens, scraped records, output items, raw error messages, stack traces, or hashes of any of those values. Records are kept for no longer than 13 months, used only as aggregated operational statistics, and never sold or shared.

Additional fields (Phase 2)

This Actor also records your Apify user ID, whether Apify marks the account as paying, the size range of list inputs, the selected country when the input offers a fixed list of countries, and one category from a fixed Actor taxonomy. We use these fields only for aggregate reliability, repeat-use and cross-Actor analysis; reports suppress any cell with fewer than five distinct users.

The same disableUsageStats: true input flag turns these fields off too. The user ID is removed after 13 months; we do not export, sell, share, or attempt to re-identify this data.

Run-outcome signals (v2)

To learn whether a run did what it was asked to do, the record also holds a few more coarse ranges and yes/no flags. None of them contains content:

• the result limit you asked for (a range, when the input has one) and what share of it was delivered;
• results delivered per input item you listed (a range);
• output quality as ranges: how fully the result fields were filled, the share of rows that look like errors, the share of duplicate rows, and how many different fields appeared. These are counted in memory while results are saved; no result content is kept;
• how the run was started (console, API, schedule, webhook, another Actor);
• how it ended: stopped by you, timed out, reached the requested limit, stopped by the charge limit, and how many times the platform moved the run;
• if this Actor reports it: how many items to process worked or failed (ranges) and one failure reason from a fixed list;
• a short code made from the names of the input fields you set, never their values.

Repeat-run fingerprint (v2)

When your Apify user ID is recorded (see above), the record also holds an 8-character one-way code made from your input (proxy settings left out) and this Actor's name. It only lets us see that the same account ran the same input again soon after an unsatisfying run; we never see the input itself. It is stored only in the database, never published, and reports use it in aggregate with the same five-user minimum. It is the one exception to the statement above that no hashes are collected, and disableUsageStats: true turns it off.