# Target Availability Scraper (`harpoon/target-availability-scraper`) Actor

Check Target store-level stock for a list of TCINs and get one row per product per store.

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

## Pricing

from $0.80 / 1,000 product-store rows

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 Availability Scraper — see which stores have a product, and how much

Give it a list of Target products (TCINs) and the states to check, and get one row per product
per store — with the units in stock and the pickup and in-store status. Paste your TCINs, pick
the states, and press Start; the form is prefilled and runs as-is.

#### What can it do?

- Check a product at **every store** in the states you pick (or **Everywhere** for the whole US)
- Report **units in stock** per store, plus pickup and in-store availability status
- Take TCINs or product URLs as input
- Filter to only stores that currently have the item, or keep sold-out stores too
- Export results to JSON, CSV, Excel, or XML
- Run via the API, schedule runs, and integrate through webhooks or MCP

### What data can I extract?

<table>
<tr><th>What you get</th><th>Features</th></tr>
<tr><td>

- **Per store** — store name, address, city, state, ZIP, phone, in-stock flag, units in stock, pickup status and date, in-store status
- **Product label** — title, TCIN, product URL, image, price

</td><td>

- Multi-select by state, or Everywhere
- Only-in-stock filtering
- Export to JSON, CSV, Excel, XML
- API access, webhooks, SDKs
- LLM-ready output for MCP, ChatGPT, Claude

</td></tr>
</table>

### How to use Target Availability Scraper

1. [Create](https://console.apify.com/sign-up) a free Apify account.
2. Open **Target Availability Scraper** in Apify Console.
3. Enter the **TCINs** to check (one per line).
4. Pick the **States to check** (or **Everywhere**).
5. Click **Save & Start**, then download results in JSON, CSV, Excel, or XML.

### Input

- `tcins` — the Target products to check, one per line (TCINs or product URLs).
- `states` — the states whose stores are checked, or **Everywhere (all US states)**.
- `max_stores_per_tcin` — cap on how many stores are checked (and returned) per TCIN; `0` (default) means every store in the selected states.
- `include_out_of_stock` — when off (default), only stores with the item in stock are returned.

**Example input**

```json
{
  "tcins": ["85978619"],
  "states": ["RI"]
}
```

See the **Input** tab above for every parameter.

### Output

Results land in a dataset under the **Storage** tab. Each row is one product at one store. View as
a table, download in JSON, CSV, Excel, or XML, or pull them via the API.

The sample below is a real row from a run with the example input.

```json
{
  "tcin": "85978619",
  "title": "Apple AirPods 5 Wireless Earbuds with Active Noise Cancellation and Wireless Charging Case",
  "url": "https://www.target.com/p/apple-airpods-5-wireless-earbuds-with-active-noise-cancellation-and-wireless-charging-case/-/A-85978619",
  "image_url": "https://target.scene7.com/is/image/Target/GUEST_ae16b1ac-87be-4292-bafc-d1cc07f5ae41",
  "price": 149.99,
  "price_text": "$149.99",
  "store_id": "2073",
  "store_name": "Lincoln",
  "address": "620 George Washington Hwy",
  "city": "Lincoln",
  "state": "RI",
  "state_name": "Rhode Island",
  "zip": "02865-4216",
  "phone": "401-642-0080",
  "in_stock": true,
  "stock_quantity": 5,
  "pickup_status": "IN_STOCK",
  "pickup_date": "2026-09-29",
  "in_store_status": "IN_STOCK"
}
```

Field names are lowercase snake\_case. The **Overview** dataset view shows the product image, the
store, the stock and the pickup status.

### What can you do with the data?

Each recipe names the exact input and fields to use.

#### 1. Find the nearest store that has an item

1. Run with your `tcins` and a state.
2. Filter `in_stock: true` and sort by `stock_quantity`.
3. Use each store's `address`, `city`, and `phone` to plan the trip.

#### 2. Monitor stock across a whole state

1. Pick a state (or Everywhere) and schedule the run every few hours.
2. Compare `stock_quantity` per `store_id` between runs to see restocks.

#### 3. Feed a store-level stock dashboard

1. Run with `include_out_of_stock: true` to get every store.
2. One row is already one product per store — pivot on `store_id`.
3. Chart units per store, or flag stores below a reorder threshold.

### How much does Target Availability Scraper cost?

Pricing is pay-per-event, so you only pay for what a run returns:

- **`availability`** — **$1 per 1,000 rows**. Each charge adds one product-per-store row to the
  dataset.

A run with 5 TCINs over one state's stores is a fraction of a cent; a whole-country run costs by
the number of stores it checks. See the **Pricing** tab for current rates.

### FAQ

**Do I need an account, cookies, or an API key?**
No. You run the Actor from your Apify account and it reads publicly available product and store
information.

**How do I find a product's TCIN?**
It's the number in the product URL after <code>A-</code>, for example <code>.../-/A-85978619</code>. You can paste the whole URL instead.

**Can I get private or restricted content?**
No. It returns publicly listed products and publicly available store stock only.

**How many rows will I get?**
One row per product per store that carries the item (optionally only in-stock stores). Result count
scales with the number of TCINs, the states selected, and the number of stores in them.

**Is it legal to use?**
It collects publicly available information only. Review Apify's guidance on legal and ethical
scraping for your use case.

**Can I use it with the API / SDKs / MCP?**
Yes — see the **API** tab above, or connect through the Apify MCP server.

**Something isn't working.**
Open an issue in the **Issues** tab with your input and the run log. Stock changes constantly, so a
"0 units" row can simply mean the item sold out since the run.

### Notes and limitations

- Stock is a snapshot from when the run executed; it changes constantly.
- Availability covers only the states you select.
- Covered states check every store; **Everywhere** checks every US store and takes longer.
- A row reflects the exact TCIN you entered, which for products with variants is one specific
  variant.

### Support

Found a bug or have feedback? Open an issue in the **Issues** tab.

# Actor input Schema

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

Target product TCINs to check, one per line. Also accepts product URLs (<code>https://www.target.com/p/-/A-85978619</code>).

## `states` (type: `array`):

Pick one or more states (use the search box to filter), or <b>Everywhere (all US states)</b>. Every store in each selected state is checked, and one row is returned per product per store.

## `max_stores_per_tcin` (type: `integer`):

Cap on how many stores are checked (and returned) for each TCIN. Lower values make a run faster and cheaper. Use <code>0</code> (default) for every store in the selected states.

## `include_out_of_stock` (type: `boolean`):

When off (default), only stores that currently have the product in stock are returned.

## Actor input object example

```json
{
  "tcins": [
    "85978619",
    "80585769"
  ],
  "states": [
    "RI",
    "DE"
  ],
  "max_stores_per_tcin": 0,
  "include_out_of_stock": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

One row per product per store, with units in stock and pickup status. Export as JSON, CSV, Excel, or XML.

# 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 = {
    "tcins": [
        "85978619"
    ],
    "states": [
        "RI"
    ],
    "max_stores_per_tcin": 0,
    "include_out_of_stock": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("harpoon/target-availability-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 = {
    "tcins": ["85978619"],
    "states": ["RI"],
    "max_stores_per_tcin": 0,
    "include_out_of_stock": False,
}

# Run the Actor and wait for it to finish
run = client.actor("harpoon/target-availability-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 '{
  "tcins": [
    "85978619"
  ],
  "states": [
    "RI"
  ],
  "max_stores_per_tcin": 0,
  "include_out_of_stock": false
}' |
apify call harpoon/target-availability-scraper --silent --output-dataset

```

## MCP server setup

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