# Tractor Supply Scraper: Prices, Deals & Store Stock (`vant47/tractor-supply-scraper`) Actor

Get Tractor Supply prices for chicken feed, dog food or cat litter by ZIP or store. Export online and pickup prices, dated public Neighbor's Club offers, UPCs, pack sizes and pickup stock. Search, categories or product links. $0.004 per product: 1,000 cost $4. No login.

- **URL**: https://apify.com/vant47/tractor-supply-scraper.md
- **Developed by:** [fortbrand](https://apify.com/vant47) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **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

## Tractor Supply Scraper: Prices, Deals & Store Stock

For price analysts, feed and pet brands, comparison services and resellers monitoring Tractor Supply products. Get live prices, regular prices, public promotions with dates, UPCs, manufacturer part numbers and selected-store pickup and shipping stock. Select a store or ZIP, search for products, browse categories or monitor known SKUs. **About $0.004 per delivered product: 20 products cost $0.08 and 1,000 cost $4**, plus a minimum $0.00005 Actor start charge. No retailer login or retailer API key is required.

### Read the price scope

Every observation keeps `onlinePrice` and `pickupPrice` separate. When the source supplies a numeric pickup price for the selected physical store, `price` is that pickup price and `priceScope` is `selected-store-pickup`. Otherwise `price` is the online price and `priceScope` is `online`. `regularPrice` always follows the same channel as `price`. A store ID beside an online price does not turn it into a shelf-price measurement.

The retailer's public lookup verifies the store, address and price zone. Price responses must match the selected store and zone. ZIPs choose the nearest returned store; save its ID for repeatable monitoring.

### What you get

Core columns match the US retail family; size variants have separate SKU rows.

| Field | Meaning |
| --- | --- |
| `verdict` | Readable product, price channel and stock summary. |
| `retailer`, `country`, `currency` | Tractor Supply, US and USD. |
| `storeId`, `storeName`, `location` | Verified physical store and requested ZIP. |
| `productId`, `sku` | Actual item part number, stored as text. |
| `gtin` | Supplied UPC, preserving leading zeros. |
| `title`, `brand`, `size` | Product identity and explicit package-size information. |
| `price`, `regularPrice`, `onSale` | Current one-time price, source base price and comparison flag. |
| `promoText`, `promoType` | Main public promotion and its source type. |
| `promoStart`, `promoEnd` | Promotion validity timestamps where supplied. |
| `memberPrice`, `memberProgram` | Explicit member-price fields; absent numeric member prices remain null. |
| `unitPrice`, `unitOfMeasure` | Supplied unit-price fields; absent values remain null. |
| `inStock`, `stockLevel` | Availability for `stockScope`, with missing channel evidence left null. |
| `rating`, `reviewCount` | Product aggregate rating and review count. |
| `category` | Source category identifiers for joining taxonomy data. |
| `url`, `imageUrl`, `scrapedAt` | Product page, product image and UTC observation time. |

Additional fields preserve the channel and matching evidence:

| Field | Meaning |
| --- | --- |
| `onlinePrice`, `onlineRegularPrice` | Online one-time purchase amounts. |
| `pickupPrice`, `pickupRegularPrice` | Selected-store pickup amounts when supplied. |
| `priceScope`, `fulfillmentType` | Channel selected for the common price fields. |
| `shelfPrice` | Physical shelf price; null without a shelf observation. |
| `shippingInStock`, `shippingStockLevel` | Public shipping inventory signal and quantity. |
| `pickupInStock`, `pickupStockLevel` | Numeric pickup inventory evidence, when available. |
| `pickupEligible`, `availability` | Catalog fulfillment eligibility, separate from current stock. |
| `priceStoreId`, `priceZoneId`, `zoneId` | Returned price context and resolved store zone. |
| `parentProductId`, `catalogEntryId` | Product-family part number and catalog entry identifier. |
| `manufacturerPartNumber`, `modelNumber` | Source manufacturer and model identifiers. |
| `bagWeight`, `packCount` | Explicit bag-weight and package-count metadata. |
| `bulkPriceTiers` | Structured quantity-discount terms, retaining the public wording and dates. |
| `offers` | Public offer IDs, text, types and validity dates. |
| `publicRewardsTerms` | Public rewards wording, without calculating personal points. |
| `storeAddress`, `storeDistance` | Location evidence returned by store lookup. |
| `details` | Optional description and specifications. |
| `recordType` | PRODUCT for observations; NOTE for free explanatory rows. |

### Public offers and Neighbor's Club

A first-subscription percentage discount can have a maximum saving, channel restriction or minimum order. Those conditions stay with the offer. A bulk offer is recorded separately from the price of one package. Rewards wording does not establish a cash member price. `memberPrice` therefore stays null unless an explicit numeric member price is supplied.

`dealsOnly` keeps a product when it has a lower current price than regular price or an active public offer. A Smart Supply offer can qualify even when the one-time price is unchanged. Filter `onSale` when you specifically want a one-time price reduction. The deals view shows offers. Free DEALS JSON contains only `isDeal: true` rows, with linked parts for large exports.

### Start in three steps

1. Enter search terms, category/product links or product part numbers.
2. Choose ZIP codes or exact physical store IDs and set the product limits.
3. Run, check SUMMARY for coverage, then export JSON, CSV or Excel.

The prefill searches chicken feed near ZIP 37027, capped at 20 products. Its first live cloud test on 5 November 2026 delivered 20 distinct observations, with 20 product charges and no failed requests, in 16.53 seconds. The test resolved Grassland (Franklin), TN store 2314. Source response speed and your selected inputs affect each run.

### Inputs

| Input | Use |
| --- | --- |
| `searchTerms` | Terms such as chicken feed, dog food, cat litter or fencing. Each term runs at every store. |
| `startUrls` | Optional Tractor Supply category, catalog, search or product HTTPS links. |
| `productIds` | Item SKUs or parent part numbers, for example 5013040 or 135276099. |
| `locations` | US ZIP codes, for example 37027, 75001 or 30301. |
| `storeIds` | Exact physical store numbers; these take precedence over ZIPs. |
| `maxItemsPerSearch` | Maximum new observations per source and store, default 20, maximum 1,000. |
| `maxItems` | Total product/store observations, default 20, maximum 10,000. |
| `dealsOnly` | Keep sales and products with active public promotions. |
| `includeDetails` | Attach public descriptions and specifications, with no extra product charge. |
| `proxyConfiguration` | Default datacenter selection first, then US residential retries. Custom settings are supported. |
| `postalCodes`, `categoryUrls` | Optional aliases for ZIP selection and additional category links. |

Use an empty search list when you only want exact products or categories. With no sources supplied, chicken feed is the default search. With no location selection, the Actor resolves the reference store near ZIP 37027 and marks the requested location as null. It always returns the selected store identity. Input arrays support up to 100 entries. A source limit is a ceiling, not a guarantee that the source has that many priced matches.

Two searches at two ZIPs can return up to 80 observations, about $0.32 at base pricing:

```json
{
  "searchTerms": ["dog food", "cat litter"],
  "locations": ["37027", "75001"],
  "maxItemsPerSearch": 20,
  "maxItems": 80
}
```

Monitor an exact item at a repeatable store:

```json
{
  "productIds": ["5013040"],
  "storeIds": ["2314"],
  "includeDetails": true,
  "maxItemsPerSearch": 10,
  "maxItems": 10
}
```

Browse a category using the retailer's actual category hierarchy:

```json
{
  "startUrls": ["https://www.tractorsupply.com/tsc/catalog/dog-food"],
  "locations": ["30301"],
  "maxItemsPerSearch": 50,
  "maxItems": 50
}
```

### Output and coverage

The overview, deals and full-data views organize the output. Keep identifiers as text in spreadsheets.

Every run writes SUMMARY to its default key-value store. It includes product and store counts, deals, product charges, duplicate exclusions, source outcomes, resolved stores, free failures and the spending-limit result. Inspect this record before treating a scheduled snapshot as complete. Free NOTE rows explain invalid inputs and unavailable source data. Notes and summaries have no product charge.

### Price and spending limits

Saved observations and charge receipts survive reboots. Delivery and charging are serial; ambiguous billing evidence stops further charging. Requests are paced, with fresh-session retries and US residential fallback.

One distinct SKU at one store is one product. The same SKU at two stores is two observations. Overlapping searches, categories and product links at the same store are delivered and charged once within a run. Failed requests, unpriced items, duplicates, free notes and empty summaries have no Product charge. There is no additional default dataset-row fee.

| Delivered products | Base | Bronze | Silver | Gold |
| --- | --- | --- | --- | --- |
| 20 | $0.08 | $0.076 | $0.072 | $0.064 |
| 100 | $0.40 | $0.38 | $0.36 | $0.32 |
| 1,000 | $4.00 | $3.80 | $3.60 | $3.20 |

The base product price is $0.004; Bronze is $0.0038, Silver $0.0036 and Gold $0.0032. Add the minimum $0.00005 Actor start charge. Optional details use the same product fee. Set Apify's maximum total charge to control larger jobs. The Actor checks available Product capacity before requesting and delivering further pages and stops cleanly when that limit is reached.

### Monitor prices every day

Make, Zapier, n8n, Sheets and webhooks can read the dataset and SUMMARY.

Save your store IDs and a stable basket of SKUs in an Apify task. In Console, add the task to a schedule, choose the daily time and timezone you need, then connect a completed-run webhook to your database or workflow.

Join snapshots using `retailer + storeId + sku`, with `scrapedAt` as the observation timestamp. Keep `priceScope` in every comparison. Compare pickup with pickup and online with online; retain regular price and offer conditions in separate columns. Every scheduled run takes observations and charges for its delivered products again. Store snapshots in your own database to build price history.

### API examples

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/vant47~tractor-supply-scraper/runs' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["chicken feed"],"locations":["37027"],"maxItems":20}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("vant47/tractor-supply-scraper").call(
    run_input={"productIds": ["5013040"], "storeIds": ["2314"], "maxItems": 10}
)
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('vant47/tractor-supply-scraper').call({
  searchTerms: ['dog food'], locations: ['75001'], maxItems: 20
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### Use with AI agents (MCP)

Connect your Apify account to `https://mcp.apify.com`. Ask for Tractor Supply SKU prices and public offer dates at specified ZIPs or store IDs. Give the agent your searches or known product numbers and a maximum product count. Ask it to inspect SUMMARY, retain nulls and include priceScope in its final table.

### Limits

Dedicated sale and clearance landing-page URLs are not accepted; use searches or categories with dealsOnly.

Category URL mappings include a dated metadata fallback, verified against the live category API. Prices, promotions and stock are fetched fresh.

Pickup prices are returned when the public price response supplies them. Verified physical shelf prices are not covered. Pickup stock comes from the retailer's selected-store inventory response, with matching location IDs; future receipts are excluded. Catalog pickup eligibility does not establish current stock. Shipping inventory stays separate. Common stock fields follow the price channel and remain null when that channel cannot be verified.

Unit and member prices and some model or package fields remain null. Manufacturer part number formatting can vary across public responses. Subscription and bulk terms remain conditional. Promotions can differ by date, channel, quantity, membership or account eligibility. Personalized rewards, clipped coupons, checkout, customer accounts and review bodies are outside coverage. No personal points are calculated.

Some products have no public numeric price or are no longer available. They are omitted without a Product charge. Product images and metadata can change. Search ordering follows the retailer's public catalog and can vary. The source can refuse requests or change its public routes; SUMMARY records request failures. No scraper can guarantee uninterrupted source availability.

### FAQ

**Can I choose an exact store?** Yes. Use physical storeIds for repeatable monitoring, or ZIPs for the nearest returned store.

**Is every price a store shelf price?** No. Read priceScope. Pickup and online amounts are separate, and shelfPrice remains null.

**Do public offers change price?** Only the source's one-time advertised price populates price. Conditional promotion text stays in offers.

**Does includeDetails add another charge?** No. It adds public descriptions and specifications to the same Product row.

**What happens with duplicates or bad input?** Duplicates are free. Parseable invalid input produces a free note and summary. Apify can reject schema-invalid input before a run starts.

**Is this affiliated with Tractor Supply?** No; this is an independent tool.

# Actor input Schema

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

Search for chicken feed, dog food, cat litter, tools or other public products. Leave empty when using only product IDs or URLs.

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

Optional Tractor Supply category, catalog, search or product HTTPS links.

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

Tractor Supply SKU or parent part number, such as 5013040 or 135276099. Actual variants are resolved before pricing.

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

US ZIP codes. The nearest store is returned with its address and price zone. An empty selection resolves the reference store near 37027.

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

Exact physical store numbers. Each store is verified; these take precedence over ZIP codes.

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

Maximum new product rows from each term, category or deals source at one store. Duplicates are free.

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

Global limit across all products and stores. About $0.004 per product: 20 products cost about $0.08 plus the small start charge.

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

Keep products with a sale price or a current public promotion. Subscription offers keep their purchase conditions; no account is used.

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

Include the public long description and specifications at no additional product charge.

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

Default: datacenter first, with US residential only after refused datacenter attempts. You may supply your own proxy configuration.

## `postalCodes` (type: `array`):

Optional alias of locations.

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

Optional additional Tractor Supply category URLs.

## Actor input object example

```json
{
  "searchTerms": [
    "chicken feed"
  ],
  "locations": [
    "37027"
  ],
  "maxItemsPerSearch": 20,
  "maxItems": 20,
  "dealsOnly": false,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `dealsView` (type: `string`):

No description

## `dealsOnly` (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": [
        "chicken feed"
    ],
    "locations": [
        "37027"
    ],
    "maxItemsPerSearch": 20,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("vant47/tractor-supply-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": ["chicken feed"],
    "locations": ["37027"],
    "maxItemsPerSearch": 20,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("vant47/tractor-supply-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": [
    "chicken feed"
  ],
  "locations": [
    "37027"
  ],
  "maxItemsPerSearch": 20,
  "maxItems": 20
}' |
apify call vant47/tractor-supply-scraper --silent --output-dataset

```

## MCP server setup

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