# GOAT Universal Scraper (`scrapifier/goat-universal-scraper`) Actor

👟 Scrape GOAT by keyword or URL: sneakers, streetwear, bags and more. Get lowest price, instant-ship price, last sold and the full per-size resale market in any currency. SKU, colorway, designer and images. Cookies optional, pay per result.

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

## Pricing

$3.00 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## GOAT Scraper

Scrape GOAT, one of the biggest sneaker and streetwear marketplaces, by keyword or by pasting any GOAT product, search, brand or collection URL, and export sneakers, apparel, bags and accessories with their full resale market as JSON, CSV or Excel, or pull them straight from the API.

⚡ For every product you get the **title, brand, silhouette, SKU, release date, retail price**, image and **product URL**, plus the live market in the currency you choose: **lowest price, instant-ship lowest price**, and whether it trades **under retail**. Turn on the detail options and each row also carries the **full size run**, where every size has its own lowest price for new and used, instant-ship price, **last sold price** and stock status, plus the complete **product details** (SKU, colorway, designer, season, size range, story and all images). Read prices in **any currency**. Login is optional. You **pay per product**.

[![Apify Actor](https://apify.com/actor-badge?actor=scrapifier/goat-universal-scraper)](https://apify.com/scrapifier/goat-universal-scraper)

### 🎯 Why scrape GOAT?

- **Reseller pricing and repricing**: read the lowest price and instant-ship price per size to price your own listings and spot the spread you can capture.
- **Buy-low signals**: filter to products trading **under retail**, or sort by most wanted, to find flips before they trend.
- **Sell-timing and analytics**: last sold price per size and condition tells you what the market actually pays right now.
- **Inventory and portfolio tracking**: watch your own SKUs on a schedule and log lowest price, instant-ship price and last sold over time.
- **Cross-platform arbitrage**: compare GOAT prices against other marketplaces to find gaps.
- **Sneaker and streetwear datasets**: titles, SKUs, release dates, colorways, images and prices at scale for matching, enrichment or machine learning.

### 📊 What data does GOAT Scraper extract?

| Field | Description |
|---|---|
| `productId`, `slug` | GOAT's unique product id and URL slug |
| `title`, `brand`, `silhouette` | Product title, brand and model / silhouette |
| `sku` | Manufacturer style ID / SKU |
| `gender`, `productType`, `category` | Segment and category classification |
| `releaseDate`, `retailPrice` | Release date and original retail price |
| `underRetail`, `inStock` | Whether it trades under retail and has active inventory |
| `market` | Live market in the selected currency: `lowestPrice`, `instantShipLowestPrice` |
| `sizes` | Full size run when requested: each size with `lowestPriceNew`, `lowestPriceUsed`, `instantShipLowestPrice`, `lastSoldPrice`, `inStock` |
| `sizeRange` | All sizes the product is issued in (product details) |
| `color`, `designer`, `details`, `nickname` | Colorway, designer and edition details (product details) |
| `story`, `season`, `midsole` | Description, season and build details (product details) |
| `images`, `imageUrl` | All product images and the main image |
| `activities` | Activity tags (lifestyle, running, basketball...) |
| `url`, `searchInput`, `position` | Product page URL and which input produced the row |

### 🚀 How to scrape GOAT

1. Type your **search keywords** (`jordan 1`, `dunk low panda`, a brand, a model, or a SKU like `DD1391-100`), one per line.
2. Or paste **GOAT URLs**: a product page, a search results page, a brand page, or a collection page. Product pages always return their full details and the complete size market.
3. Pick your **currency** (USD, EUR, GBP, JPY and more) and **country / market**, so every price matches the market you sell in.
4. Optionally **sort** (most wanted, newest, price low to high, price high to low), keep only a **brand**, **gender**, **product type** or **condition**, filter to **under retail** or **instant ship**, or set a **min / max price**.
5. Turn on the detail options you need: **per-size market**, **full product details**.
6. Set **Max products** and click **Start**. Open the **Storage** tab to preview the rows and export them as JSON, CSV, Excel or XML, or read them from the dataset API.

The same run can be started from the Apify API, the Python or JavaScript client, or put on a schedule for continuous market tracking.

### 📥 Input parameters

| Field | Key | Type | Default | Description |
|---|---|---|---|---|
| Search keywords | `queries` | array | `jordan 1` (prefill) | One search per line. Brand, model, category words or a SKU. |
| Start URLs | `startUrls` | array of URLs | none | GOAT product, search, brand or collection URLs. |
| Currency | `currency` | select | `USD` | Currency for every price: USD, EUR, GBP, CAD, AUD, JPY, CHF, HKD, KRW, SGD, MXN, NZD. |
| Country / market | `country` | string | `US` | Two-letter market code used for per-size availability (US, GB, FR, DE, JP...). |
| Sort order | `sort` | select | `relevance` | Relevance, most wanted, newest, price low to high, price high to low. |
| Brands | `brands` | array | none | Keep only these brands (e.g. Air Jordan, Nike, adidas). |
| Gender | `gender` | select | any | Keep only men, women, youth, infant or unisex. |
| Product type | `productType` | select | any | Keep only sneakers, apparel, accessories or bags. |
| Condition | `condition` | select | any | Keep only new, new with defects, used or GOAT Clean. |
| Under retail only | `underRetail` | boolean | `false` | Keep only products trading under retail. |
| Instant ship only | `instantShip` | boolean | `false` | Keep only products with instant-ship inventory. |
| Min / max price | `minPrice`, `maxPrice` | integer | none | Keep products whose lowest price falls in the range. |
| Max products (total) | `maxItems` | integer | `100` | Hard cap across all searches. This is also your cost cap. |
| Max products per search | `maxItemsPerQuery` | integer | none | Optional cap per keyword or URL. |
| Include full product details | `includeProductDetails` | boolean | `false` | Attach SKU, colorway, designer, story, size range and all images. |
| Include per-size market | `includeSizeMarket` | boolean | `false` | Attach each size's own lowest price, instant-ship price, last sold price and stock. |
| Account cookies | `sessionCookies` | array | none | Optional. Paste your account cookies to run logged in when your account has more access. |
| Proxy configuration | `proxyConfiguration` | object | Residential | Residential proxies are recommended for reliable runs. |

### 📤 Output example

```json
{
  "productId": "529535",
  "slug": "air-jordan-4-retro-black-cat-2020-cu1110-010",
  "title": "Air Jordan 4 Retro 'Black Cat' 2020",
  "brand": "Air Jordan",
  "silhouette": "Air Jordan 4",
  "sku": "CU1110 010",
  "gender": "men",
  "productType": "sneakers",
  "releaseDate": "2020-01-25",
  "retailPrice": 190,
  "underRetail": false,
  "imageUrl": "https://image.goat.com/attachments/product_template_pictures/images/.../original/529535_00.png.png",
  "url": "https://www.goat.com/sneakers/air-jordan-4-retro-black-cat-2020-cu1110-010",
  "market": {
    "currency": "GBP",
    "lowestPrice": 143,
    "instantShipLowestPrice": 152
  },
  "sizes": [
    {
      "size": "9",
      "sizeValue": 9,
      "lowestPriceNew": 143,
      "lowestPriceUsed": 118,
      "instantShipLowestPrice": 152,
      "lastSoldPrice": 149,
      "inStock": true
    }
  ],
  "sizesCollected": 26,
  "color": "Black",
  "designer": "Tinker Hatfield",
  "story": "The Air Jordan 4 Retro 'Black Cat' 2020 returns the stealthy monochrome colorway...",
  "searchInput": "https://www.goat.com/sneakers/air-jordan-4-retro-black-cat-2020-cu1110-010"
}
```

### 💡 Ready-to-run examples

- **Full size market for a product**: paste the product URL in `startUrls`. One row with every size's lowest price, instant-ship price and last sold. Product URLs always include full details and the size market.
- **Under-retail deal radar**: `queries: ["jordan 1"]`, `underRetail: true`, `sort: "price_low_high"`. Only products trading under their original retail.
- **Most wanted movers**: `queries: ["dunk low"]`, `sort: "most_wanted"`, `includeSizeMarket: true`. The hottest models with per-size liquidity.
- **Price in your selling market**: `queries: ["travis scott"]`, `currency: "EUR"`, `country: "FR"`. Lowest and instant-ship prices in euros for the French market.
- **Instant-ship only**: `queries: ["new balance 2002r"]`, `instantShip: true`. Products that ship immediately, no authentication wait.
- **Whole brand watch**: paste `https://www.goat.com/brand/new-balance`, set `sort: "most_wanted"`, and schedule it daily.
- **Portfolio tracking**: put your SKUs in `queries` (e.g. `DD1391-100`), turn on `includeSizeMarket`, and log lowest price and last sold over time.

### 💰 Pricing: how much does it cost to scrape GOAT?

You pay **per product row**, nothing else: no subscription, no starting fee. A product with its full size run and details attached still counts as **one** result. The detail options make runs slower, not more expensive per row. A typical market watch (200 products with per-size data on) costs well under a dollar per run. Set `maxItems` to control your spend exactly.

### ⚙️ Performance, proxies and limits

- **24 products per results page** are collected in one request, so keyword searches are fast even at thousands of products.
- Each detail option adds one request per product; expect roughly 1 to 2 seconds per product with all options on. The base search rows already include the product-level market at no extra request.
- **Residential** proxies are recommended for reliable runs. If a run reports `blocked` in its output, confirm residential proxies are selected and retry; the Actor also rotates sessions automatically.
- Rows are deduplicated by product id within a run, so overlapping searches never produce duplicates or double charges.
- Prices are read live at run time in the currency you select; per-size availability follows the country you choose.

### 🔌 Integrations and API

Start the Actor from the [Apify API](https://docs.apify.com/api/v2), the [Python](https://docs.apify.com/api/client/python/) or [JavaScript](https://docs.apify.com/api/client/js/) client, or a webhook, and connect the dataset to Google Sheets, Slack, Make, Zapier or your own pipeline through [Apify integrations](https://apify.com/integrations).

Run synchronously and get the products in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapifier~goat-universal-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["dunk low panda"], "currency": "USD", "maxItems": 20, "includeSizeMarket": true}'
```

Schedule it (hourly, daily, weekly) from the **Schedules** tab to build your own market tracker.

### ❓ FAQ

**Is it legal to scrape GOAT?**
The Actor collects publicly available product and market data, the same information any visitor sees. You are responsible for how you use the data; respect applicable laws and GOAT's terms.

**Do I need a GOAT account or API key?**
No. You can scrape the public market anonymously with no login. Providing your account cookies is optional and only useful when your account unlocks additional access.

**How do I run it as my own account?**
Paste your GOAT account cookies into the **Account cookies** field, as a browser cookie export or as `name=value` lines. Leave it empty to run anonymously.

**Can I get prices in my own currency and market?**
Yes. Set the **Currency** and **Country / market** fields. Every price is returned in that currency, and per-size availability follows the selected country.

**How do I get every size's price for a product?**
Turn on **Include per-size market**, or paste the product URL directly; pasted product pages always return the full size run with lowest price, instant-ship price and last sold per size.

**What is the difference between lowest price and instant-ship price?**
The lowest price is the cheapest offer overall; the instant-ship price is the cheapest offer that ships immediately from GOAT without the usual authentication wait, so it is often a little higher.

**Can I filter by brand, condition or under retail?**
Yes. Use the brand, gender, product type, condition, under-retail and instant-ship filters, or paste a brand or collection URL as a start URL to scrape exactly that view.

**Which categories are supported?**
Everything GOAT sells: sneakers, apparel, bags, accessories and collectibles.

**What does the `blocked` error in the run output mean?**
The site refused the connection for the IP used. Confirm residential proxies are selected and run again; the Actor also rotates sessions automatically.

### 🔗 Related scrapers

- [StockX Universal Scraper](https://apify.com/scrapifier/stockx-universal-scraper): sneaker and streetwear resale market with per-size asks and bids.
- [Vinted Scraper](https://apify.com/scrapifier/vinted-universal-scraper): second-hand fashion listings and prices.
- [Idealo Price Comparison Scraper](https://apify.com/scrapifier/idealo-price-comparison-universal-scraper): shop prices and price history across Europe.
- [Trustpilot Scraper](https://apify.com/scrapifier/trustpilot-universal-scraper): company reviews and ratings.
- [Leboncoin Scraper](https://apify.com/scrapifier/leboncoin-universal-scraper): listings from France's biggest marketplace.

### 💬 Support

Found a bug, missing a field, need another market or a custom feature? Open an **Issue** on the Actor page and I usually answer within a day. If this scraper saves you time, a ⭐ review on the Actor page helps a lot.

# Actor input Schema

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

Products to search for, one per line (e.g. <code>jordan 1</code>, <code>dunk low panda</code>, a brand, a model, or a SKU like <code>DD1391-100</code>). Each keyword becomes one GOAT search.

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

GOAT URLs to scrape directly: a product page (returns full product details and the size market), a search results page, or a brand / collection page (paginated automatically).

## `currency` (type: `string`):

Currency for every price in the output.

## `country` (type: `string`):

Two-letter country code used for per-size availability and delivery (e.g. US, GB, FR, DE, JP).

## `sort` (type: `string`):

How to order search results before the cap is applied.

## `brands` (type: `array`):

Keep only these brands (e.g. <code>Air Jordan</code>, <code>Nike</code>, <code>adidas</code>). Leave empty for all.

## `gender` (type: `string`):

Keep only products of this gender.

## `productType` (type: `string`):

Keep only this product type.

## `condition` (type: `string`):

Keep only products offered in this condition.

## `underRetail` (type: `boolean`):

Keep only products whose lowest price is under their original retail price (deals).

## `instantShip` (type: `boolean`):

Keep only products with instant-ship inventory (ships immediately, no authentication wait).

## `minPrice` (type: `integer`):

Keep only products whose lowest price is at or above this value (in the selected currency).

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

Keep only products whose lowest price is at or below this value (in the selected currency).

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

Hard cap on the total number of products across all searches and URLs. You pay per result, so this is also your cost cap.

## `maxItemsPerQuery` (type: `integer`):

Optional cap per individual keyword or URL. Leave empty to only use the total cap.

## `includeProductDetails` (type: `boolean`):

Attach full product data: SKU, colorway, designer, story, season, size range and all images. Adds one request per product.

## `includeSizeMarket` (type: `boolean`):

Attach the full size run with each size's own lowest price (new and used), instant-ship price, last sold price and stock status. This is the core reseller data. Adds one request per product.

## `sessionCookies` (type: `array`):

Optional. Paste your GOAT account cookies (as a browser cookie export array, or name=value lines) to run as your logged-in account, which can unlock account-specific access. Leave empty to scrape the public market anonymously.

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

Proxy settings. Residential proxies are recommended for reliable runs.

## `verbose` (type: `boolean`):

Log progress details for every search.

## Actor input object example

```json
{
  "queries": [
    "jordan 1"
  ],
  "currency": "USD",
  "country": "US",
  "sort": "relevance",
  "gender": "",
  "productType": "",
  "condition": "",
  "underRetail": false,
  "instantShip": false,
  "maxItems": 50,
  "includeProductDetails": false,
  "includeSizeMarket": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "verbose": true
}
```

# Actor output Schema

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

All GOAT products extracted by this run.

# 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 1"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapifier/goat-universal-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 1"],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapifier/goat-universal-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 1"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapifier/goat-universal-scraper --silent --output-dataset

```

## MCP server setup

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