# Grailed Listings & Price-Spread Scraper (`xtracto/grailed-listings`) Actor

Search Grailed menswear/streetwear resale for any designer or keyword and get every listing with price, size, condition, seller, and sold status. Compare min-to-max prices across sizes for spread arbitrage. No login.

- **URL**: https://apify.com/xtracto/grailed-listings.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Grailed Listings & Price-Spread Scraper

Search Grailed — the menswear/streetwear resale marketplace — for any designer, brand, or keyword and get back every matching listing with its price, size, condition, seller, and sold status. Built for price-spread arbitrage: see the full min-to-max price range across sizes and conditions for the same item.

### Why use this actor

- **No account, no login, no API key needed.** Just enter a search term and run.
- **Full listing detail:** title, designer/brand, asking price, any price drops, size, condition, department, seller, photo, and listing link.
- **Sold-price history:** flip on "sold only" to pull completed sales with the real sold price — perfect for valuing an item before you buy or list.
- **Price-spread ready:** every listing carries price + size + condition, so you can compute the min↔max spread across a query in a spreadsheet.
- **Stable JSON output** suitable for pipelines, databases, and spreadsheets. Export to JSON, CSV, or Excel.
- **Automatic retries**, runs on Apify's schedule — no scrapers, browsers, or blocks to babysit.

### How it works

1. You provide one or more search terms (e.g. `nike`, `supreme box logo`).
2. The actor searches Grailed for each term.
3. It walks through the result pages and collects every listing, up to the limits you set.
4. Each listing is returned as one clean row with price, size, condition, seller, and sold status.
5. Export the dataset to JSON/CSV/Excel or pull it via the Apify API.

You never manage scrapers, browsers, or blocks — the actor handles retries and returns clean rows.

### Input

```json
{
    "queries": ["nike", "supreme box logo"],
    "mode": "search",
    "soldOnly": false,
    "minPrice": 0,
    "maxPrice": 0,
    "hitsPerPage": 48,
    "maxItemsPerSearch": 96,
    "maxItems": 0,
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

| Field | Type | Description |
| --- | --- | --- |
| `queries` | array of strings | Search terms — keywords, brands, or designers. Each is searched separately. |
| `mode` | string | `search` (only mode). Returns matching listings for each query. |
| `soldOnly` | boolean | When `true`, returns only sold listings with their final sold price. |
| `minPrice` | integer | Only listings priced at or above this (USD). `0` = no minimum. |
| `maxPrice` | integer | Only listings priced at or below this (USD). `0` = no maximum. |
| `hitsPerPage` | integer | Listings fetched per page (1–100). Default 48. |
| `maxItemsPerSearch` | integer | Max listings per query (`0` = all available, up to ~1000 per query). |
| `maxItems` | integer | Overall cap across all queries (`0` = no cap). |
| `proxyConfiguration` | object | Optional. Search is public; Residential is a safe default. |

### Output

Each row is one listing. A convenient set of lead fields is placed first, followed by the full original listing detail.

#### Sample (available listing, query `nike`)

```json
{
    "_query": "nike",
    "_mode": "active",
    "_source": "S1-search",
    "_scrapedAt": "2026-07-09T18:41:12Z",
    "id": 100438088,
    "title": "VTG Nike Faux Fur Jersey Zip Hoodie Y2K",
    "designerNames": "Nike",
    "price": 75,
    "priceDropsTo": null,
    "soldPrice": 0,
    "isSold": false,
    "soldAt": null,
    "size": "m",
    "condition": "is_gently_used",
    "categoryPath": "tops.sweatshirts_hoodies",
    "department": "menswear",
    "location": "Europe",
    "makeoffer": true,
    "sellerId": 15748731,
    "sellerUsername": "oldornew",
    "listingUrl": "https://www.grailed.com/listings/100438088",
    "firstPhoto": "https://media-assets.grailed.com/prd/listing/temp/5b0dcccb6b9d4aa39a846e350092b2fa",
    "createdAt": "2026-07-09T18:40:27.030Z",
    "price_drops": [55, 38],
    "designers": [{ "id": 30, "name": "Nike" }],
    "user": { "id": 15748731, "username": "oldornew", "seller_score": { "rating_average": 4.9, "rating_count": 40 } }
    // … full original listing fields also included
}
```

#### Sample (sold listing, `soldOnly: true`, query `supreme box logo`)

```json
{
    "_query": "supreme box logo",
    "_mode": "sold",
    "_source": "S1-search",
    "id": 85546402,
    "title": "Supreme Box Logo Sticker (pack of 10)",
    "designerNames": "Supreme",
    "price": 13,
    "soldPrice": 13,
    "isSold": true,
    "soldAt": "2026-07-09T17:44:18.361Z",
    "size": "one size",
    "condition": "is_new",
    "categoryPath": "accessories.supreme",
    "sellerUsername": "sohohypebeast",
    "listingUrl": "https://www.grailed.com/listings/85546402"
    // … full original listing fields also included
}
```

| Field | Type | Description |
| --- | --- | --- |
| `id` | number | Listing id. |
| `title` | string | Listing title. |
| `designerNames` | string | Designer / brand name(s). |
| `price` | number | Current asking price (USD). |
| `priceDropsTo` | number/null | Latest dropped-to price when the seller has reduced it, else `null`. |
| `soldPrice` | number | Final sold price (populated for sold listings). |
| `isSold` | boolean | Whether the listing has sold. |
| `soldAt` | string/null | When it sold (sold listings). |
| `size` | string | Listed size. |
| `condition` | string | Item condition (e.g. `is_new`, `is_gently_used`). |
| `categoryPath` | string | Category path (e.g. `tops.sweatshirts_hoodies`). |
| `department` | string | Department (e.g. `menswear`). |
| `location` | string | Seller location. |
| `makeoffer` | boolean | Whether the seller accepts offers. |
| `sellerId` / `sellerUsername` | number / string | Seller identity. |
| `listingUrl` | string | Direct link to the listing. |
| `firstPhoto` | string | Cover photo URL. |
| `createdAt` | string | When the listing was posted. |
| `price_drops`, `designers`, `user`, … | mixed | Full original listing detail, kept as-is. |

Rows that fail carry an `_error` field instead of listing fields, so problems are never silent.

### Notes / limits

- **~1000 listings per query.** Grailed's search returns up to roughly 1,000 results for any single term. For more volume, split into several narrower terms (e.g. by model or colorway) or add price ranges.
- **Available vs. sold are separate.** Available listings come from the live catalog; turn on `soldOnly` to pull completed sales with sold prices.
- **Prices are in USD.**
- A proxy is optional because search is public. Residential is a safe default in the Console.

# Actor input Schema

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

Keywords, designers, or item names to search Grailed for (e.g. "nike", "supreme box logo", "raf simons"). Each query is searched separately and returns listings with prices and sizes.

## `mode` (type: `string`):

What to return. "Search" returns matching listings for each query.

## `soldOnly` (type: `boolean`):

When on, returns only sold listings (with the final sold price) instead of currently-available listings. Useful for comparing sold vs. asking prices.

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

Only return listings priced at or above this amount. Leave at 0 for no minimum.

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

Only return listings priced at or below this amount. Leave at 0 for no maximum.

## `hitsPerPage` (type: `integer`):

How many listings to fetch per request (1-100). Higher is faster; the default of 48 matches the website.

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

Maximum listings to return for each individual query (0 = as many as available, up to ~1000 which is the search cap per query).

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

Overall cap across all queries combined (0 = no overall cap).

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

Proxy settings. Grailed search is public, so a proxy is optional; Residential is a safe default.

## Actor input object example

```json
{
  "queries": [
    "nike"
  ],
  "mode": "search",
  "soldOnly": false,
  "minPrice": 0,
  "maxPrice": 0,
  "hitsPerPage": 48,
  "maxItemsPerSearch": 96,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        "nike"
    ],
    "maxItemsPerSearch": 96
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/grailed-listings").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": ["nike"],
    "maxItemsPerSearch": 96,
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/grailed-listings").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "nike"
  ],
  "maxItemsPerSearch": 96
}' |
apify call xtracto/grailed-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=xtracto/grailed-listings",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Grailed Listings & Price-Spread Scraper",
        "description": "Search Grailed menswear/streetwear resale for any designer or keyword and get every listing with price, size, condition, seller, and sold status. Compare min-to-max prices across sizes for spread arbitrage. No login.",
        "version": "0.1",
        "x-build-id": "iWJ1OvUbrtAcZnUTQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~grailed-listings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-grailed-listings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/xtracto~grailed-listings/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-grailed-listings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/xtracto~grailed-listings/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-grailed-listings",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords, designers, or item names to search Grailed for (e.g. \"nike\", \"supreme box logo\", \"raf simons\"). Each query is searched separately and returns listings with prices and sizes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search"
                        ],
                        "type": "string",
                        "description": "What to return. \"Search\" returns matching listings for each query.",
                        "default": "search"
                    },
                    "soldOnly": {
                        "title": "Sold listings only",
                        "type": "boolean",
                        "description": "When on, returns only sold listings (with the final sold price) instead of currently-available listings. Useful for comparing sold vs. asking prices.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or above this amount. Leave at 0 for no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or below this amount. Leave at 0 for no maximum.",
                        "default": 0
                    },
                    "hitsPerPage": {
                        "title": "Listings per page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many listings to fetch per request (1-100). Higher is faster; the default of 48 matches the website.",
                        "default": 48
                    },
                    "maxItemsPerSearch": {
                        "title": "Max listings per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listings to return for each individual query (0 = as many as available, up to ~1000 which is the search cap per query).",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max listings total",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Overall cap across all queries combined (0 = no overall cap).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Grailed search is public, so a proxy is optional; Residential is a safe default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
