# Target Scraper: Prices, Circle Deals & Stock by Store (`moggedhq/target-scraper`) Actor

Get Target products with store prices where shown and separate online prices: sale and regular price, Target Circle deals and dates, unit price, pickup and delivery stock, UPC, TCIN, ratings and reviews. Search, categories or product links. About $0.004 per product: 1,000 cost $4. No login.

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

## Pricing

from $3.20 / 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Target Scraper: Prices, Circle Deals & Stock by Store

For price analysts, brands and resellers monitoring Target prices, promotions and stock. About **$0.004 per product at one store**: 1,000 product-store rows cost **$4**, plus the small Actor start charge. No Target login is needed.

Choose ZIP codes or exact Target store IDs. Get physical-store prices when Target exposes them, separate online prices, regular prices, public Target Circle coupons, promotion dates, unit prices, UPCs, TCINs and fulfillment states. Search by product words, browse categories and deals pages, or monitor known product links and IDs.

### What you get

| Field | Meaning |
| --- | --- |
| `retailer`, `country`, `currency` | Target, US and USD. |
| `storeId`, `storeName` | Verified Target physical store used for the observation. |
| `location` | Requested ZIP code; null for an exact store ID or the signed-out default. |
| `productId`, `tcin` | Target's product identifier, retained as text. |
| `sku`, `dpci` | Target's department-class-item identifier when supplied. |
| `gtin`, `upc` | Published barcode as text, preserving leading zeroes. |
| `title`, `brand`, `size` | Product title, brand and an explicitly displayed size. |
| `price` | Current price only when the source identifies the requested physical store. |
| `regularPrice`, `onSale` | Regular physical-store price and its comparison with the current price. |
| `promoText`, `promoType` | Public sale, clearance, multi-buy, BOGO or Circle offer wording and classification. |
| `promoStart`, `promoEnd` | Source dates for the first dated promotion; inspect individual promotions for separate windows. |
| `memberPrice` | Explicit numeric member price when supplied, otherwise null. Coupon savings are not subtracted to invent a price. |
| `memberProgram` | Target Circle when a public Circle offer is present. |
| `unitPrice`, `unitOfMeasure` | Source unit price for the physical-store price, without recalculating it from package size. |
| `inStock`, `stockLevel` | In-store state and the available-to-promise quantity Target supplies. |
| `rating`, `reviewCount` | Average rating and written review count, when available. |
| `category`, `url`, `imageUrl`, `scrapedAt` | Category, product link, primary image and collection timestamp. |
| `onlinePrice`, `onlineRegularPrice`, `onlineOnSale` | Separate online amounts and sale comparison. |
| `onlineFormattedPrice`, `onlineUnitPrice` | Online display price, including ranges, and numeric unit price when exposed. |
| `priceScope`, `pricingNote` | Whether a matching physical-store price was provided, with an explanation when it was not. |
| `priceStoreId`, `sourcePriceStoreId` | Verified physical pricing store and original source pricing location. |
| `fulfillment` | Separate in-store, pickup, same-day delivery and shipping states. Pickup date is included when shown. |
| `promotions` | Individual public offer records, including IDs, exact dates, thresholds, rewards and conditions when exposed. |
| `circleOffers` | Public non-personalized Circle coupon values, expiry dates, fulfillment eligibility and activation conditions. |
| `ratingCount`, `ratingScope` | Rating count separately from written reviews, and whether statistics describe the product or its parent family. |
| `storeZip`, `detailStatus` | Resolved store ZIP and whether product detail data was available. |

Missing fields remain null. A null stock state means Target did not expose a confirmed state for that fulfillment method. It is different from an explicit out-of-stock response. `stockLevel` is the source's available-to-promise quantity, which can be capped; it is not a promise of the store's full shelf inventory.

With `includeDetails: true`, rows also contain the public description, specification bullets, ingredients, nutrition information and additional image links when available. Individual customer reviews, reviewer identities and account data are not collected.

### Start in three steps

1. Enter words in `searchTerms`, or supply Target product/category links in `startUrls`, or numeric TCINs in `productIds`.
2. Choose `locations` using five-digit US ZIP codes, or use `storeIds` for reproducible comparisons at exact stores. Set the row limits before running.
3. Run the Actor and open the overview or deals dataset view. Download JSON, CSV, Excel or another supported dataset export.

The prefilled example searches for milk near ZIP 10001 and returns up to 20 products. At list price, 20 rows cost about $0.08 plus the $0.00005 minimum start charge. Validation on 28 October 2026 delivered 20 rows in 44 seconds. The final varied-input test matrix completed 38 of 38 cases with useful product results or the expected empty/free response.

### Inputs

| Input | Type and default | How to use it |
| --- | --- | --- |
| `searchTerms` | Array of strings; milk when no other source is supplied | Example: `["milk", "coffee", "laundry detergent"]`. Clear it to `[]` for a URL-only or ID-only job. |
| `startUrls` | Optional array | Target product links containing `A-<TCIN>`, category or filtered deals links containing `N-<category>`, and search links containing `searchTerm`. |
| `productIds` | Optional array | Known TCINs, such as `["13276134", "81875472"]`. |
| `locations` | Optional array | Five-digit ZIP codes. The nearest returned store within the source's lookup radius is selected and named in every row. |
| `storeIds` | Optional array | Exact Target store identifiers. Invalid or unavailable stores produce free notes. |
| `maxItemsPerSearch` | Integer; 20 | Maximum delivered products for each search or category at each store. |
| `maxItems` | Integer; 20 | Total product-store row limit across all sources and stores. |
| `dealsOnly` | Boolean; false | Return only a public sale, clearance, promotion or Circle coupon match. |
| `includeDetails` | Boolean; false | Add ingredients, nutrition, descriptions, specifications and more image links. No separate detail charge. |
| `proxyConfiguration` | Optional proxy object | Automatic mode uses US datacenter first, fresh sessions on retries, and US residential only as the final retry. Custom proxy settings are also accepted. |

A ZIP selects one nearest store. ZIPs resolving to the same store are deduplicated. With both location inputs empty, the Actor records the signed-out site default.

`maxItems` counts product-store rows. For example, to get up to 10 products at each of five stores, use `maxItemsPerSearch: 10` and `maxItems: 50`. A low global limit can be reached before later stores are processed.

Deals-only mode scans a bounded sample: up to five times the source limit, at least 120 and at most 10,000 products. It does not enumerate every Target offer. The summary records scan counts.

### Example jobs

#### Compare milk prices in five locations

```json
{
  "searchTerms": ["milk"],
  "locations": ["10001", "90210", "60601", "77002", "98101"],
  "maxItemsPerSearch": 10,
  "maxItems": 50,
  "includeDetails": false
}
```

#### Find cereal promotions with dates

```json
{
  "searchTerms": ["cereal"],
  "storeIds": ["1849"],
  "dealsOnly": true,
  "maxItemsPerSearch": 20,
  "maxItems": 20
}
```

On 28 October 2026, the source exposed “Buy 2 for $9 cold cereal” from `2026-10-25T07:00:00Z` to `2026-11-01T06:59:59Z`. This dated example keeps the single-item price separate from the conditional offer.

#### Monitor known products and public Circle coupons

```json
{
  "searchTerms": [],
  "productIds": ["95010191", "23974815"],
  "storeIds": ["1849"],
  "includeDetails": true,
  "maxItems": 10
}
```

Circle coupon values such as `$5 off` retain expiry dates and conditions. Activation, membership and fulfillment restrictions can apply; the value never becomes an invented final price. Personalized offers are excluded.

### A real product observation

This observation was collected on 28 October 2026 for the nearest store to ZIP 10001:

```json
{
  "retailer": "Target",
  "storeId": "3412",
  "storeName": "Chelsea 23rd and 8th",
  "location": "10001",
  "productId": "13276134",
  "title": "Vitamin D Whole Milk - 1gal - Good & Gather™",
  "gtin": "085239284056",
  "price": 4.79,
  "regularPrice": 4.79,
  "unitPrice": 0.04,
  "unitOfMeasure": "fluid ounce",
  "inStock": true,
  "priceScope": "store"
}
```

That same product was observed at $4.59 at store 1849 during validation. Store choice matters. Prices, offer windows and stock can change after collection; use `scrapedAt` when comparing observations.

### Monitor prices every day

Save a task with the same TCINs or search terms and exact store IDs. In Apify Console, create a schedule for that task, choose a daily time and set the spending limit. Keep the task's product and store limits explicit so the recurring bill remains predictable.

Export through the API, webhooks, Make, Zapier or n8n. Join on `retailer`, `storeId` and `productId`. Compare physical-store and online prices separately. Prices and stock are fresh each run; public configuration is briefly cached. Durable checkpoints prevent repeat charges after reboots.

### Price and spending control

There is one primary product charge and no extra charge for `includeDetails`.

| Delivered product-store rows | List product charge |
| --- | --- |
| 20 | $0.08 |
| 100 | $0.40 |
| 1,000 | $4.00 |
| 10 products at 5 stores | $0.20 |

The minimum Actor start charge is $0.00005 for the standard memory allocation. Bronze has 5% off product rows, Silver 10%, and Gold, Platinum and Diamond 20%. The applicable tier is shown by Apify before the run.

Duplicates, failed lookups, invalid-input notes, empty searches and the run summary have no product charge. A valid row with an unavailable physical-store price can still be useful and charged: it carries explicit price coverage, separate online prices when available, verified store stock and product identifiers. Check `priceScope` when selecting rows for a physical-store price analysis.

The Actor checks the spending allowance before delivering a paid row. If another product will not fit, it stops with the completed rows and a spending-stop summary.

### API use

Create an Apify API client and call `moggedhq/target-scraper` with the same input JSON used in Console.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("moggedhq/target-scraper").call(run_input={
    "searchTerms": ["milk"],
    "locations": ["10001"],
    "maxItems": 20,
    "maxItemsPerSearch": 20,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
products = [row for row in items if row.get("productId")]
```

The default dataset supports standard Apify exports. `SUMMARY` is a free key-value-store record with product, store and deal counts, free failures, resolved stores, source results and the spending-stop flag. Note rows have a `noteId` and no `productId`, so filter for `productId` when importing product observations into a strict table.

Requests are paced; raise the timeout for large jobs. Standard memory is 512 MB.

### Use with AI agents (MCP)

Connect your MCP-compatible client to `https://mcp.apify.com` and enable this Actor. Ask the agent to inspect the input schema, choose a product-store limit and confirm the expected product charge before starting a larger job.

### Limits and reliability

Only public signed-out US Target data is used. There is no account login, cart checkout, CAPTCHA solving or access to personalized Circle offers. Product-level ingredient and nutrition data is included only when Target supplies it. No value is guessed from a similar product or another store.

The Actor uses paced HTTP requests, fresh proxy sessions for retries, Retry-After handling, bounded scans and durable product-store deduplication. Refused sources produce free notes and a partial summary after retries. An upstream data gap is reported explicitly; a successful run status alone does not mean every requested source returned all fields.

Online prices and parent price ranges remain separate from physical-store prices. `ratingScope` labels parent-family ratings. Shipping never establishes in-store stock. Target search may return related or recommended products for unmatched terms; use TCINs for exact monitoring.

### FAQ

**Why is `price` null while `onlinePrice` has a value?** Target returned an online price without identifying the requested physical pricing store. The Actor keeps those contexts separate.

**Does a Circle coupon become my final price?** No. Activation, eligibility, quantities and fulfillment restrictions can apply. The coupon is returned as an offer with its conditions.

**Can I collect only deals?** Yes. Set `dealsOnly: true`, or use the deals view to inspect qualifying rows from a broader run.

**Does `stockLevel: 10` mean exactly ten units on the shelf?** No. It is the available-to-promise quantity the source provides and may be capped.

**Do duplicate links cost extra?** The same TCIN at the same store is delivered and charged once within a run. A new scheduled run is a new observation.

**What happens after a reboot?** Saved rows and charge receipts are reconciled before more products are delivered. The validation includes a real cloud reboot between row delivery and its product charge.

Use this Target scraper for Target products, Target prices, Circle deals, dated promotions, UPC catalog checks and store stock monitoring with explicit price context.

# Actor input Schema

## `searchTerms` (type: `array`):

Search Target products, for example milk, coffee or headphones. Each search runs for each chosen store.

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

Optional Target product, category, deals category or search links. Product links must contain A- followed by a TCIN.

## `productIds` (type: `array`):

Optional numeric Target TCINs. Clear searchTerms for a product-only run.

## `locations` (type: `array`):

Find the nearest Target store for each ZIP. Every row records the resolved store. Empty uses the signed-out site default store.

## `storeIds` (type: `array`):

Optional exact Target store IDs. They are verified before retrieving prices. Different stores produce separate product rows.

## `maxItemsPerSearch` (type: `integer`):

Maximum delivered products per search or category at each store. Deals-only mode scans a bounded sample to find offers.

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

Maximum product-store rows across the whole run. The same TCIN in two stores counts as two rows.

## `dealsOnly` (type: `boolean`):

Deliver only products with a current sale, clearance or a public promotion. Empty deal searches are free of product charges.

## `includeDetails` (type: `boolean`):

Include public description, specification bullets, ingredients, nutrition and extra image links. UPC, prices, promotions and store stock are included in the base product row.

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

Optional Apify or custom proxy settings. Automatic mode starts with US datacenter proxy and retries using a fresh session, then US residential only if necessary.

## Actor input object example

```json
{
  "searchTerms": [
    "milk"
  ],
  "startUrls": [],
  "productIds": [],
  "locations": [
    "10001"
  ],
  "storeIds": [],
  "maxItemsPerSearch": 20,
  "maxItems": 20,
  "dealsOnly": false,
  "includeDetails": false
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `deals` (type: `string`):

No description

## `summary` (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 = {
    "searchTerms": [
        "milk"
    ],
    "startUrls": [],
    "productIds": [],
    "locations": [
        "10001"
    ],
    "storeIds": [],
    "maxItemsPerSearch": 20,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/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 = {
    "searchTerms": ["milk"],
    "startUrls": [],
    "productIds": [],
    "locations": ["10001"],
    "storeIds": [],
    "maxItemsPerSearch": 20,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/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 '{
  "searchTerms": [
    "milk"
  ],
  "startUrls": [],
  "productIds": [],
  "locations": [
    "10001"
  ],
  "storeIds": [],
  "maxItemsPerSearch": 20,
  "maxItems": 20
}' |
apify call moggedhq/target-scraper --silent --output-dataset

```

## MCP server setup

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