# Target Scraper: Store Inventory, Clearance & Stock Checker (`s_actors/target-scraper`) Actor

Scrape Target products with price, clearance and the units on hand in each store near a ZIP code. Check stock of any TCIN, UPC or DPCI in all nearby stores (a BrickSeek alternative), list clearance in stock at your store, get only-changes alerts.

- **URL**: https://apify.com/s\_actors/target-scraper.md
- **Developed by:** [Superior Actors](https://apify.com/s_actors) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 1 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.

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: Store Inventory, Clearance & Stock Checker

Check **how many units of any Target product are in each store** near a ZIP code, in one run. Paste TCINs, links, **UPC barcodes or DPCIs** and get stock in the **1-20 nearest stores**, like BrickSeek but pay-per-result and ready for automation. Or search by keyword or category and get **price, clearance and units in your stores**, or list **all clearance in stock at your store**.

Schedule it with **Only report changes** and get just the news: **price drops, new clearance, back in stock, sold out**.

Export as **JSON, CSV, Excel or HTML**, or use it as a **Target API**. No browser, no login, no proxy setup.

#### How it works

1. Choose what to do: **Check stock of products in nearby stores**, **Search products in stores** or **Find stores near a ZIP code**
2. Add products (TCIN, target.com link, UPC or DPCI), or keywords (`lego`), or target.com category links
3. Add a US **ZIP code** and how many of the nearest stores to check (or exact store numbers, any state)
4. Optional: filters (**Only clearance**, **Only in stock**, **Minimum discount %**, **Maximum price**) and **Only report changes** for scheduled alerts (see [Monitoring](#only-report-changes-how-monitoring-works))

#### Why this Actor

| | |
|---|---|
| 🏬 **Units in every nearby store** | One product in up to 20 stores around a ZIP in a single request: units on hand, store status, pickup |
| 🔢 **TCIN, UPC or DPCI** | Paste what you have: a TCIN, a link, a barcode or the DPCI from the shelf tag (`204-00-0505`) |
| 🏷️ **Clearance in stock at your store** | The clearance department filtered to items your store actually carries, with % off and units |
| 👕 **Every size and color** | A product with variants is checked for each variant, with its own DPCI and UPC |
| 🔔 **Only changes** | Scheduled runs return only price drops, new clearance, back in stock and sold out |
| 🔎 **Search & categories** | Any keyword, category or brand page, up to 1,200 products per search, sorted like target.com |
| 💰 **Cheaper than BrickSeek** | BrickSeek Premium costs $14.99 a month; checking 20 items in 5 stores daily here costs about $1.50 a month |

#### Use cases

- **Inventory checker**: which Target near you has an item, and how many units
- **Restock alerts**: Stanley tumblers, LEGO, Nintendo Switch 2, Hot Wheels: get told when your stores have them again
- **Pokémon card restock tracker**: every official Pokémon TCG product sold by Target (Elite Trainer Boxes, Booster Bundles, tins), in your stores, online and anywhere in the US (see [Pokémon restocks](#pok%C3%A9mon-card-restocks))
- **Clearance hunting and retail arbitrage**: clearance items in stock at the stores in your area, with % off
- **Price tracker**: daily alerts when an item drops in price or goes on clearance
- **Product data**: TCIN, DPCI, UPC, brand, rating and image for any search or category
- **AI agents**: give your assistant live Target stock and prices through the Apify MCP server

#### Stock in nearby stores

Real example, September 2026: LEGO Botanicals Rocking Plants (TCIN `94939978`, DPCI `204-00-0505`), the 5 stores nearest to ZIP 10001 (Manhattan), one request:

| Store | Miles | Units | Status | Pickup |
|---|---|---|---|---|
| Manhattan Herald Square | 0.3 | 5 | IN\_STOCK | IN\_STOCK |
| Chelsea 23rd and 8th | 0.3 | 8 | IN\_STOCK | IN\_STOCK |
| Times Square 42nd Street | 0.7 | 5 | IN\_STOCK | IN\_STOCK |
| Manhattan Hells Kitchen | 0.9 | 3 | IN\_STOCK | IN\_STOCK |
| Kips Bay | 1.0 | 5 | IN\_STOCK | IN\_STOCK |

A clearance row from **Only clearance** + **Only in stock** in Minneapolis (store 1375, 859 clearance items carried): Women's Barrel Leg Crop Sweatpants, `price` **$18.75**, `regularPrice` $25, `discountPercent` 25, `storeQuantity` 4.

| Field | Description |
|---|---|
| `tcin`, `title`, `brand`, `dpci`, `upc` | The product (`upc` in stock-check mode) |
| `price`, `regularPrice`, `discountPercent` | Price today, regular price and % off |
| `priceType`, `isClearance`, `saleEnds` | `reg`, `sale` or `clearance`; when a sale ends |
| `storeQuantity`, `inStockAtStore` | Units Target shows for this store |
| `storeStatus`, `pickupStatus`, `shipToStoreStatus` | `IN_STOCK`, `LIMITED_STOCK`, `OUT_OF_STOCK`, `NOT_SOLD_IN_STORE`, `DISCONTINUED` |
| `onlineStatus`, `outOfStockInAllStores` | Online (ship to home) stock; sold out in every store |
| `storeId`, `storeName`, `storeAddress`, `storeCity`, `storeState`, `storeZip`, `storeDistanceMiles` | The store |
| `itemType`, `rating`, `reviewsCount`, `image`, `url`, `parentTcin` | Product page data; `parentTcin` for a size or color variant |
| `query`, `queryType`, `redirectedTo` | The input this row came from; popular searches like "toys" open a category page, shown in `redirectedTo` |

**Check stock** asks Target for each product once and gets all nearby stores in that answer. With **Store numbers** instead of a ZIP it checks up to 24 products per store in one request. **Search products in stores** takes the products from the first (nearest) store and checks the same products in the other stores.

#### Find stores near a ZIP code

| Field | Description |
|---|---|
| `storeId`, `storeName` | Store number (use it in **Store numbers**) and name |
| `street`, `city`, `state`, `zip`, `phone`, `distanceMiles`, `hoursToday` | Address, distance from the ZIP code, today's hours |

#### Only report changes: how monitoring works

Monitoring turns a scheduled run into alerts. It works in three steps:

1. **Switch on** **Only report changes** and pick a **Monitor name** (one name per list of items or searches)
2. **Save as a task and schedule it**, for example every morning (Actor page → Save as a new task → Schedule)
3. **First run** saves prices and stock and returns everything marked `change: new`. **Every later run** compares with the previous run and returns only the differences. An empty result means nothing changed

| `change` | When |
|---|---|
| `price_drop`, `price_increase` | The price changed (`previousPrice` shows the old one) |
| `clearance_started`, `clearance_ended` | The item went on clearance or left it |
| `back_in_stock`, `out_of_stock` | The store has it again, or sold out |
| `online_back_in_stock`, `online_out_of_stock` | target.com can ship it again, or sold out online (once per product, on its first store row) |
| `in_stock_somewhere` | The item was sold out in every Target store and now at least one US store has it: the earliest restock signal for Pokémon cards and other hard-to-find items |
| `quantity_change` | Units in the store changed by at least **Report stock count changes of at least** (off by default) |
| `new_item` | A new product appeared in the search or category, or a new store near the ZIP |

Filters apply to the reported rows, so **Only in stock** with monitoring returns only items that came back in stock. Use a different **Monitor name** for each task, otherwise two tasks overwrite each other's memory. You pay for the requests and for the changes returned, not for unchanged items.

#### Pokémon card restocks

Target search mixes official Pokémon TCG products with marketplace sellers (imported Japanese packs at resale prices, never in stores). To watch only what Target itself sells, including items that are sold out right now, use this category link, which has the filters **Sold by Target** and **Include out of stock**:

`https://www.target.com/c/pokemon/-/N-4yka5Zdq4mnZfwtfrZtkle6`

In September 2026 it returned 288 official products; 282 of them were sold out in every US store. Schedule it with **Only report changes** every 15-60 minutes and you get a row only when something changes:

| Signal | Field / `change` |
|---|---|
| Back on the shelf in one of your stores, with units | `back_in_stock`, `storeQuantity` |
| Back online (ship to home) | `online_back_in_stock` |
| Back in at least one US store (was sold out everywhere) | `in_stock_somewhere` |

A full check of the 288 products in 1 store is about 24 requests, about **$0.015 per run** when nothing changed.

#### Pricing

Pay per result, no subscription:

| Event | Price |
|---|---|
| Run start | $0.002 |
| Target request (a search page of 24 products, prices and units of 24 products in one store, one product in up to 20 nearby stores, or a product page) | $0.0005 |
| Product in a store (a returned row; rows removed by filters and unchanged rows in monitoring are free) | $0.001 |
| Store (Find stores near a ZIP code) | $0.0005 |

| Task | Cost |
|---|---|
| Stock of 1 item in the 20 nearest stores | ~$0.02 |
| Stock of 10 items in the 5 nearest stores | ~$0.06 |
| 100 products for a keyword in 1 store | ~$0.11 |
| Restock alerts: 20 items in 5 stores, checked daily, only changes | ~$0.70 per month |
| Clearance at your store: 480 items, daily, only changes | ~$1.00 per month |

#### Ready-made tasks

Open one, change the ZIP code, keywords or items, and run:

| Task | What you get |
|---|---|
| [Target Inventory Checker: Stock in Stores Near a ZIP](https://apify.com/s_actors/target-scraper/examples/target-inventory-checker) | Units of an item in the 20 nearest stores |
| [Target Pokémon Restock Tracker: Online, In Store, Anywhere](https://apify.com/s_actors/target-scraper/examples/target-pokemon-restock-tracker) | Only Pokémon TCG restocks: your 3 stores with units, online, any US store |
| [Target Pokémon Stock Checker: Cards in Stock Near You](https://apify.com/s_actors/target-scraper/examples/target-pokemon-stock-checker) | Newest ETBs and Booster Bundles in the 20 stores near a ZIP |

#### Input example

```json
{
    "mode": "stock_check",
    "products": ["94939978", "204-00-7234", "https://www.target.com/p/-/A-86216189"],
    "zipCode": "10001",
    "maxStores": 10,
    "onlyChanges": true,
    "monitorName": "my-items"
}
```

#### Tips

- **TCIN** is the number after `A-` in a product link: `target.com/p/.../-/A-94939978` → `94939978`. **DPCI** is on the shelf tag and the receipt (`204-00-0505`). A **UPC** barcode works too.
- **Category links**: open a category or brand page on target.com and copy its address (it ends with `/N-` and an ID). Clearance is `https://www.target.com/c/clearance/-/N-5q0ga`. **Filtered links work too**: pick a department, brand or discount on target.com and paste the address (`N-5q0gaZ5xtvd` = clearance in Home & Decor).
- **Prices** are Target's national prices (what target.com shows). Target does not publish store-specific shelf prices, so in-store-only markdowns can be lower than `price`. Stock is per store.
- **Units** are what Target shows for store pickup ("Only 8 left"); the shelf can differ by a few.
- **Only in stock** in search mode also limits the list to products sold in the first store, so **Only clearance** + **Only in stock** = clearance your store carries.
- US stores only.
- Other stores: [Home Depot inventory and clearance](https://apify.com/s_actors/home-depot-scraper), [Walmart restock tracker](https://apify.com/s_actors/walmart-restock-tracker) (online stock). Send results to email, Slack or [Google Sheets](https://apify.com/s_actors/google-sheets-import-export) with integrations.

# Actor input Schema

## `mode` (type: `string`):

Search products: keywords or category links, with price and units in each store (turn on "Only clearance" to list clearance). Check stock: specific products in all Target stores near a ZIP code, like BrickSeek. Find stores: Target stores near a ZIP code with their numbers.

## `keywords` (type: `array`):

Search mode: what to search on target.com, one per line (e.g. "lego", "air fryer", "pokemon cards").

## `categoryUrls` (type: `array`):

Search mode: target.com category or brand page links (they end with "/N-" and an ID), e.g. https://www.target.com/c/clearance/-/N-5q0ga.

## `products` (type: `array`):

Check stock mode: TCINs (the number after "A-" in a target.com link), product links, UPC barcodes or DPCIs (e.g. 204-00-0505), one per line. A product with sizes or colors is checked for each variant.

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

US ZIP code. The nearest Target stores are used (see "Stores to check").

## `maxStores` (type: `integer`):

How many of the nearest stores to the ZIP code to check (1-20). Each product is returned once per store.

## `radiusMiles` (type: `integer`):

Only stores within this distance from the ZIP code.

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

Optional: exact Target store numbers (e.g. 3412) instead of the nearest stores, any state. Find them with "Find stores near a ZIP code".

## `maxProductsPerSearch` (type: `integer`):

Search mode: how many products to take from each keyword or category (24 per page, Target shows up to 1,200).

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

Search mode: order of the products, as on target.com.

## `onlyClearance` (type: `boolean`):

Search inside Target's clearance department. With no keywords, lists all clearance items.

## `onlyInStock` (type: `boolean`):

Return only products the store has on the shelf. In search mode the list itself is limited to products sold in the first store.

## `minDiscountPercent` (type: `integer`):

Return only products at least this much off the regular price (clearance or sale). 0 = all.

## `maxPrice` (type: `integer`):

Return only products at or below this price. Empty = any price.

## `onlyChanges` (type: `boolean`):

For scheduled runs. The first run saves prices and stock; later runs return only products whose price dropped or rose, went on clearance, came back in stock or sold out (in your stores or online), or came back in any US store, and products new to the search. You pay only for the changes returned.

## `minQuantityChange` (type: `integer`):

Also report when the number of units in a store changes by at least this many. 0 = only in stock / sold out.

## `monitorName` (type: `string`):

Separate monitors keep separate memory. Use a different name for each scheduled task.

## `maxConcurrency` (type: `integer`):

How many requests run at the same time.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "lego"
  ],
  "products": [
    "94939978"
  ],
  "zipCode": "10001",
  "maxStores": 5,
  "radiusMiles": 30,
  "maxProductsPerSearch": 48,
  "sortBy": "relevance",
  "onlyClearance": false,
  "onlyInStock": false,
  "minDiscountPercent": 0,
  "onlyChanges": false,
  "minQuantityChange": 0,
  "monitorName": "default",
  "maxConcurrency": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per product and store: price, clearance, units in the store.

## `stock` (type: `string`):

Units, store status and pickup in each store near the ZIP code.

## `clearance` (type: `string`):

Discounted products: price, regular price, % off, units in the store.

## `changes` (type: `string`):

Monitoring: price drops, new clearance, back in stock, sold out.

## `stores` (type: `string`):

Target stores near the ZIP code.

## `all` (type: `string`):

Every field of every row.

# 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 = {
    "keywords": [
        "lego"
    ],
    "products": [
        "94939978"
    ],
    "zipCode": "10001"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s_actors/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 = {
    "keywords": ["lego"],
    "products": ["94939978"],
    "zipCode": "10001",
}

# Run the Actor and wait for it to finish
run = client.actor("s_actors/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 '{
  "keywords": [
    "lego"
  ],
  "products": [
    "94939978"
  ],
  "zipCode": "10001"
}' |
apify call s_actors/target-scraper --silent --output-dataset

```

## MCP server setup

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