# GOAT Sneaker Prices & Per-Size Market Scraper (`malek_oweis/goat-sneaker-price-scraper`) Actor

Search GOAT or paste goat.com URLs and get lowest ask, instant-ship price, retail price and resale premium per product - plus every size's lowest ask, last sold price and stock. Gets past GOAT's Cloudflare block via a managed unblocker; no login.

- **URL**: https://apify.com/malek_oweis/goat-sneaker-price-scraper.md
- **Developed by:** [Malek Oweis](https://apify.com/malek_oweis) (community)
- **Categories:** E-commerce, Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.70 / 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

## GOAT Sneaker Prices & Per-Size Market Scraper

**GOAT blocks scrapers.** It sits behind Cloudflare and returns a 403 to any normal request, which is why the GOAT Actors on the store have only a handful of users.

This one gets through. Every request goes through a managed unblocker, and the data comes from the same public calls goat.com makes in your browser. **No login, no API key, no captcha setup from you.**

Search GOAT or paste goat.com URLs and get **one row per product** with prices, plus **every size's own market**:

### What you get per product

| Field | Meaning |
|---|---|
| `title`, `brand`, `silhouette`, `category`, `productType`, `gender` | Product identity |
| `productUrl`, `slug`, `productId`, `imageUrl` | Direct GOAT link, IDs and image |
| `retailPrice` | Original retail price |
| `lowestPrice` | Lowest ask across all sizes |
| `instantShipLowestPrice` | Lowest ask for GOAT Instant Ship (already in GOAT's warehouse) |
| `premiumVsRetailPct` | Lowest ask vs retail. `13.8` = **13.8% above** retail, `-40` = 40% below |
| `underRetail`, `inStock` | GOAT's own flags |
| `releaseDate` | Release date |
| `sizes` | **Per-size list**: `size`, `lowestAsk`, `instantShipAsk`, `lastSold`, `inStock` |
| `cheapestSize` / `cheapestSizeAsk` | The size you can buy cheapest right now |
| `priciestSize` / `priciestSizeAsk` | The size that commands the most |
| `avgLastSold`, `minLastSold`, `maxLastSold` | Last sold prices across sizes |
| `sizesListed`, `sizesInStock` | How many sizes exist and how many have stock |

Product URLs also return `sku`, `colorway` and `nickname`.

### Input

```json
{
  "queries": ["jordan 4 black cat", "nike dunk low panda"],
  "urls": ["https://www.goat.com/sneakers/air-jordan-4-retro-black-cat-2025-fv5029-010"],
  "maxProductsPerInput": 20,
  "includeSizePrices": true,
  "sizeCondition": "new"
}
```

- `queries`: keywords to search. Each is searched and paginated.
- `urls`: goat.com **search** URLs (`/search?query=...`), **collection** URLs (`/collections/...`) or **product** URLs (`/sneakers/...`, `/apparel/...`, `/bags/...`, `/jewelry/...`, `/collectibles/...`).
- `maxProductsPerInput`: stop after this many products per query/URL. `0` = no limit.
- `includeSizePrices`: per-size prices (default on). Turn off for a faster, product-level-only run.
- `sizeCondition`: `new` = brand-new shoes in a good box (default). `all` = also used, defective and damaged-box listings, each labelled with `shoeCondition` and `boxCondition`.
- `countryCode`: country for per-size prices (default `US`).
- `proxyConfiguration`: defaults to Apify Unblocker, which is **required**.

### Output

One dataset row per product, plus a `SEARCH_SUMMARY` key-value record per query/URL with
`productsScraped`, `avgLowestPrice`, `avgPremiumVsRetailPct`, `underRetailCount` and the highest-premium product.

#### Example row (trimmed)

```json
{
  "source": "jordan 4 black cat",
  "productId": "1567309",
  "title": "Air Jordan 4 Retro 'Black Cat' 2025",
  "brand": "Air Jordan",
  "silhouette": "Air Jordan 4",
  "releaseDate": "2025-11-28",
  "productUrl": "https://www.goat.com/sneakers/air-jordan-4-retro-black-cat-2025-fv5029-010",
  "currency": "USD",
  "retailPrice": 225,
  "lowestPrice": 256,
  "instantShipLowestPrice": 294,
  "premiumVsRetailPct": 13.8,
  "underRetail": false,
  "inStock": true,
  "sizes": [
    { "size": "7", "lowestAsk": 449, "instantShipAsk": 483, "lastSold": 445, "inStock": true },
    { "size": "10", "lowestAsk": 310, "instantShipAsk": null, "lastSold": 299, "inStock": true }
  ],
  "cheapestSize": "10",
  "cheapestSizeAsk": 310,
  "avgLastSold": 372,
  "sizesInStock": 2
}
```

### Use cases

- **Size-level arbitrage**: compare `lowestAsk` vs `lastSold` per size to find sizes listed below what they actually sell for
- **Cross-platform price checks**: pair it with a StockX scraper to buy on one marketplace and sell on the other
- **Sourcing research**: rank a search by `premiumVsRetailPct` to see what resells above retail
- **Inventory pricing**: price your own pairs off the current lowest ask and last sale for that exact size
- **Price tracking**: schedule daily and diff `lowestPrice` / `cheapestSizeAsk` to catch drops

### FAQ

**Why do other GOAT scrapers break?**
GOAT is behind Cloudflare. A normal request gets a 403. This Actor routes through a managed
unblocker, so it reads the same data the site loads for a real visitor.

**Do I need a proxy or captcha solver?**
No. The unblocker is the default and handles it.

**Which market are the prices for?**
The US market, in US dollars. GOAT localizes prices by visitor country, so a goat.com page opened from another country can show different numbers.

**Is this allowed?**
It reads only public product and search data, the same any visitor sees. It never logs in and
never touches account, order or buyer data. Respect GOAT's terms and your local laws.

### Use it from an AI agent (Claude, ChatGPT, Cursor, any MCP client)

This Actor works as a tool for AI agents through Apify's MCP server. Add it to your AI app with this MCP URL:

```
https://mcp.apify.com/?tools=malek_oweis/goat-sneaker-price-scraper
```

Then just ask in plain language. Example prompt:

> Search GOAT for 'jordan 4 black cat' and show the lowest ask and last sold price for every size from 8 to 12.

#### Questions this Actor answers

- What does the Jordan 4 cost on GOAT in my size?
- Which sizes of this sneaker are cheapest, and which sold last for the most?
- What is the resale premium of this shoe on GOAT compared with retail?
- Compare GOAT and StockX prices for the same sneaker.
- Which shoe sizes are out of stock on GOAT?

### Free sample dataset

Want to see real output before running it? A free sample collected with this Actor (October 2026) is
published on [Hugging Face](https://huggingface.co/datasets/malekoweis/resale-market-data/viewer/goat-sneaker-prices-by-size)
and [GitHub](https://github.com/malekoweis/resale-market-data/blob/main/data/goat-sneaker-prices-by-size.csv),
as CSV and JSONL, together with samples from the other Actors below.

### More resale and e-commerce data tools by the same developer

- [Resale Price Checker](https://apify.com/malek_oweis/resale-price-checker): one resale value per item across StockX, GOAT and Mercari
- [Etsy Shop Scraper](https://apify.com/malek_oweis/etsy-shop-seo-auditor): Etsy listings, prices and shop health
- [Shopify Store Scraper](https://apify.com/malek_oweis/shopify-store-product-price-scraper): Shopify product catalogs and prices
- [StockX Sales Data Scraper](https://apify.com/malek_oweis/stockx-search-price-scraper): StockX resale prices and sales volume
- [Chrono24 Watch Listing Scraper](https://apify.com/malek_oweis/chrono24-watch-listing-scraper): luxury watch prices on Chrono24
- [Mercari Sold Listings Scraper](https://apify.com/malek_oweis/mercari-sold-listings-scraper): Mercari US sold prices (price comps)

# Actor input Schema

## `queries` (type: `array`):

Keywords to search on GOAT, e.g. "jordan 4 black cat", "yeezy 350", "new balance 550". Each is searched and paginated.

## `urls` (type: `array`):

goat.com search URLs (https://www.goat.com/search?query=...), collection URLs (https://www.goat.com/collections/...) or product URLs (https://www.goat.com/sneakers/...). Other URLs are ignored.

## `maxProductsPerInput` (type: `integer`):

Stop after this many products for each search term or listing URL. Set 0 for no limit.

## `includeSizePrices` (type: `boolean`):

Fetch every size's lowest ask, instant-ship ask, last sold price and stock for each product. Turn off for a faster, product-level-only run.

## `sizeCondition` (type: `string`):

'new' = brand-new shoes in a good box only (what most buyers mean). 'all' = also used, defective and damaged-box listings, each labelled.

## `countryCode` (type: `string`):

Two-letter country code used for per-size prices (GOAT shows prices in US dollars).

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

GOAT is behind Cloudflare and blocks normal requests. The default - Apify Unblocker - is required. Only change this if you know what you are doing.

## Actor input object example

```json
{
  "queries": [
    "jordan 4 black cat",
    "nike dunk low panda"
  ],
  "urls": [
    "https://www.goat.com/sneakers/air-jordan-4-retro-black-cat-2025-fv5029-010"
  ],
  "maxProductsPerInput": 10,
  "includeSizePrices": true,
  "sizeCondition": "new",
  "countryCode": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}
```

# Actor output Schema

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

One row per product: lowest ask, instant-ship price, retail, resale premium, plus a per-size list of lowest ask, instant-ship ask, last sold price and stock.

## `searchSummary` (type: `string`):

productsScraped, avgLowestPrice, avgPremiumVsRetailPct, underRetailCount and the highest-premium product per query/URL.

## `overview` (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 = {
    "queries": [
        "jordan 4 black cat"
    ],
    "maxProductsPerInput": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("malek_oweis/goat-sneaker-price-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 = {
    "queries": ["jordan 4 black cat"],
    "maxProductsPerInput": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("malek_oweis/goat-sneaker-price-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 '{
  "queries": [
    "jordan 4 black cat"
  ],
  "maxProductsPerInput": 10
}' |
apify call malek_oweis/goat-sneaker-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,malek_oweis/goat-sneaker-price-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/Xgb3k7hh2A8xRqyVJ/builds/3Zo2Hq18IGd78C5cm/openapi.json