# GOAT API Scraper (`rl1987/goat-api-scraper`) Actor

Scrapes GOAT.com product listings by search query and/or category, with optional full product-detail (PDP) enrichment.

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

## Pricing

from $0.75 / 1,000 product list rows

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 API Scraper** extracts product listings from [GOAT.com](https://www.goat.com),
the sneaker/streetwear/collectibles marketplace, by **search query** and/or **category**
(Footwear, Apparel, Accessories, Bags, Collectibles, Jewelry). It calls GOAT's own
mobile-app API directly, so it's fast and doesn't render pages in a browser. Every item
includes its main image URL. Optionally, it enriches every result with full
product-detail (PDP) data — SKU, color, designer, size range, description, and
additional images — and/or per-size, per-condition variant pricing. Run it on the
Apify platform to get scheduling, API access, webhooks, and dataset export for free.

### Why use GOAT API Scraper?

- **Price monitoring** — track retail and resale pricing for specific sneakers/brands over time.
- **Catalog research** — pull a full category (e.g. all Footwear) or a filtered search (e.g. "jordan" in Apparel) for market analysis.
- **Assortment/competitor tracking** — see what's in stock, new releases, and product attributes across a category.
- **Lead lists for resale/investing tools** — feed structured product data into pricing or inventory models.

### How to use GOAT API Scraper

1. Click **Try for free** (or **Run**) on this Actor's page.
2. Set a **Search query** (e.g. `jordan`), a **Category** (e.g. `Footwear`), or both. Leave both empty to scrape all products.
3. Optionally turn on **Fetch product detail (PDP)** to include SKU, color, designer, size range, description, and additional images.
4. Optionally turn on **Fetch per-size pricing (variants)** to include a price breakdown by size, new/used condition, and box condition — GOAT prices differ per size and condition, not just per product.
5. Set **Max items** (0 = unlimited, walks every page).
6. Click **Start** and watch results land in the dataset in real time.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQuery` | string | Free-text search query. |
| `category` | string | One of `Footwear`, `Apparel`, `Accessories`, `Bags`, `Collectibles`, `Jewelry`. |
| `maxItems` | integer | Max products to scrape (0 = unlimited). Default `100`. |
| `startPage` | integer | 0-indexed PLP page to start from. Default `0`. |
| `pageSize` | integer | Products per PLP page. Default `20`. |
| `includePdp` | boolean | Also fetch full product detail (incl. additional images) per item. Default `false`. |
| `includeVariants` | boolean | Also fetch per-size/condition variant pricing per item. Default `false`. |
| `countryCode` | string | 2-letter country code for localized PDP/variant pricing. Default `NL`. |
| `proxyConfiguration` | object | Proxy config. **Required on the Apify platform** — GOAT's Cloudflare blocks Apify datacenter IPs outright, so residential proxy is used by default. |

See the **Input** tab for the full schema with defaults.

### Output

Each dataset item is one product. Example (with `includePdp: true` and `includeVariants: true`):

```json
{
  "id": "12345",
  "slug": "air-jordan-1-retro-high-og-chicago-lost-and-found",
  "productUrl": "https://www.goat.com/sneakers/air-jordan-1-retro-high-og-chicago-lost-and-found",
  "title": "Air Jordan 1 Retro High OG 'Chicago Lost and Found'",
  "brandName": "Jordan",
  "silhouette": "Air Jordan 1",
  "category": "Footwear",
  "productType": "Shoe",
  "gender": "Men's",
  "inStock": true,
  "releaseDate": "2022-11-19",
  "retailPrice": 180.00,
  "retailCurrency": "USD",
  "imageUrl": "https://image.goat.com/attachments/product_template_pictures/images/.../original.png",
  "sku": "DZ5485-612",
  "color": "Varsity Red/Black-Sail-Muslin",
  "designer": "Peter Moore",
  "sizeUnit": "US",
  "sizeRange": [7, 7.5, 8, 8.5, 9],
  "specialDisplayPrice": 350.00,
  "specialDisplayCurrency": "USD",
  "mainImageUrl": "https://image.goat.com/750/attachments/.../original.png",
  "additionalImageUrls": [
    "https://image.goat.com/attachments/product_template_additional_pictures/.../1.jpg"
  ],
  "variants": [
    { "size": 7, "sizePresentation": "7", "shoeCondition": "new_no_defects", "boxCondition": "good_condition", "price": 215.00, "currency": "USD" },
    { "size": 7.5, "sizePresentation": "7.5", "shoeCondition": "new_no_defects", "boxCondition": "good_condition", "price": 199.00, "currency": "USD" }
  ],
  "lowestVariantPrice": 199.00,
  "lowestVariantCurrency": "USD"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from
the **Storage → Dataset** tab or via the API.

### Data table

| Field | Description |
|---|---|
| `id`, `slug` | Product/template identifiers. |
| `productUrl` | Web PDP URL (opens the GOAT app directly on mobile if it's installed, via Universal/App Links). |
| `title`, `brandName`, `silhouette` | Naming and brand. |
| `category`, `productType`, `gender` | Taxonomy. |
| `inStock`, `releaseDate` | Availability. |
| `retailPrice`, `retailCurrency` | Original retail price. |
| `imageUrl` | Main product image. |
| `sku`, `color`, `designer` | *(PDP only)* Detail attributes. |
| `sizeUnit`, `sizeRange` | *(PDP only)* Available sizing. |
| `specialDisplayPrice`, `specialDisplayCurrency` | *(PDP only)* Localized current display price. |
| `mainImageUrl`, `additionalImageUrls` | *(PDP only)* Larger main image and additional product photos. |
| `variants`, `lowestVariantPrice`, `lowestVariantCurrency` | *(variants only)* Price broken down by size, new/used condition, and box condition, plus the cheapest available. |

### Cost estimation

The GOAT API is fast JSON (no browser rendering), so this Actor is cheap to run — a
few thousand PLP-only items typically cost well under $0.10 in compute units on the
Apify free tier. Enabling `includePdp` and/or `includeVariants` adds one extra HTTP request per item
each, which increases runtime and cost proportionally.

### Tips

- Leave `maxItems` at a reasonable cap for exploration; set it to `0` only when you
  intend to walk a full category (some categories have several thousand products).
  Turn on `includePdp`/`includeVariants` only when you need that extra detail — each
  one adds a request per item.
- Combine `searchQuery` and `category` to narrow results (e.g. `jordan` within `Apparel`).
- `includeVariants` is the only way to get real per-size sell prices — `retailPrice`
  is the original MSRP and doesn't reflect resale/condition-based pricing.

### FAQ & disclaimers

This Actor scrapes publicly accessible product data. It does not require or store
login credentials, and it does not collect personal data. Use it in accordance with
GOAT's Terms of Service. Website structures and APIs can change — if the Actor stops
returning data, please open an issue on the Actor's Issues tab. Need a custom variant
(different fields, sites, or pipelines)? Reach out via Apify's custom development
services.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text search query (e.g. "jordan", "adidas"). Leave empty to browse a category or all products.

## `category` (type: `string`):

Top-level category to browse. Combine with a search query to filter a query within a category.

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

Maximum number of products to scrape. Set to 0 for unlimited (walks every page until exhausted).

## `startPage` (type: `integer`):

0-indexed PLP page number to start from.

## `pageSize` (type: `integer`):

Number of products requested per PLP page.

## `includePdp` (type: `boolean`):

For every scraped product, also fetch its full product detail page (sku, color, designer, size range, description, ...) and merge it into the output item.

## `includeVariants` (type: `boolean`):

For every scraped product, also fetch per-size/condition variant pricing (price differs by shoe size, new/used condition, and box condition) and include it as a `variants` array plus a `lowestVariantPrice` summary field.

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

2-letter country code used for localized PDP pricing.

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

GOAT's Cloudflare blocks Apify's datacenter IPs outright. Residential proxy is required for runs on the Apify platform.

## Actor input object example

```json
{
  "category": "",
  "maxItems": 100,
  "startPage": 0,
  "pageSize": 20,
  "includePdp": false,
  "includeVariants": false,
  "countryCode": "NL",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `products` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/goat-api-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rl1987/goat-api-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 '{}' |
apify call rl1987/goat-api-scraper --silent --output-dataset

```

## MCP server setup

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