# Grailed Listings Scraper (`piotrv1001/grailed-listings-scraper`) Actor

The Grailed Listings Scraper extracts listings from Grailed's marketplace — capturing titles, designers, prices, price drops, sizes, conditions, colors, photos, shipping rates, sold prices, and seller ratings — ideal for resale price tracking, sold-comp research, and fashion market analytics.

- **URL**: https://apify.com/piotrv1001/grailed-listings-scraper.md
- **Developed by:** [FalconScrape](https://apify.com/piotrv1001) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 listings

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/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 Scraper

Easily extract **live and sold listings from [Grailed](https://www.grailed.com)** — the leading marketplace for designer, vintage, and streetwear fashion. The **Grailed Listings Scraper** gathers structured product data for resale market analysis, price tracking, sold-comp research, and sourcing.

Run it on the [Apify platform](https://apify.com) to get **API access, scheduling, integrations (Google Sheets, Make, Zapier, and more), automatic retries, and monitoring** out of the box — no code required.

### ✨ Features

- 🏷️ **Comprehensive Listing Data**: Titles, designer/brand, price, price drops, size, condition, color, department, category, cover photo, location, and shipping rates.
- 💰 **Sold Listings Mode**: Switch to SOLD listings to pull real final sale prices and dates — ideal for price history and market analytics.
- 👤 **Seller Insights**: Seller username, rating average, rating count, and total items bought & sold.
- 🔎 **Flexible Search**: Search by keyword, or paste Grailed search and designer page URLs directly.
- 🎯 **Smart Filtering**: Filter by department (menswear/womenswear), price range, and result count.
- 📋 **Full Details (optional)**: Enable full details to also pull the complete description, every photo, garment measurements, and the full seller profile.
- ⚡ **Fast & Reliable**: Quickly collect thousands of listings with built-in pagination — no manual browsing.

### 🛠️ How to Use the Grailed Listings Scraper

1. **Enter a search query** – Type a keyword such as a brand, designer, or item type (e.g. `nike`, `stone island`). Or paste Grailed search/designer URLs.
2. **Set your filters** – Optionally pick a department, price range, sold-only mode, and the maximum number of listings.
3. **Run the scraper** – Click **Start** and receive structured listing data in seconds.
4. **Export your data** – Download the dataset as JSON, CSV, Excel, or HTML, or pull it via the Apify API.

### 🔧 Input

| Field                   | Type    | Description                                                                         |
| ----------------------- | ------- | ----------------------------------------------------------------------------------- |
| `searchQuery`           | String  | Keyword to search Grailed for (e.g. a brand, designer, or item type).               |
| `startUrls`             | Array   | Optional Grailed search or designer page URLs to scrape instead of a keyword.       |
| `department`            | Select  | Limit results to `all`, `menswear`, or `womenswear`.                                |
| `soldOnly`              | Boolean | Scrape SOLD listings (with final price and date) instead of live ones.              |
| `minPrice` / `maxPrice` | Integer | Restrict results to a price range (USD).                                            |
| `scrapeDetails`         | Boolean | Also fetch the full description, all photos, measurements, and full seller profile. |
| `maxItems`              | Integer | Maximum number of listings to scrape (default 50).                                  |

### 📊 Sample Output Data

The scraper provides structured JSON output with key listing details. Example:

```json
[
    {
        "id": 98400943,
        "url": "https://www.grailed.com/listings/98400943",
        "title": "Stone Island RE-T Jeans denim fits w 34",
        "designer": "Stone Island",
        "department": "menswear",
        "category": "bottoms",
        "categoryPath": "bottoms.denim",
        "size": "34",
        "condition": "Gently Used",
        "color": "blue",
        "styles": ["streetwear"],
        "price": 145,
        "priceDrops": [],
        "sold": false,
        "soldPrice": null,
        "soldAt": null,
        "strata": "grailed",
        "location": "Europe",
        "coverPhoto": "https://media-assets.grailed.com/prd/listing/temp/225b31cf5d68483eb2cd31e0b58e4b40",
        "photoCount": 10,
        "measurementCount": 4,
        "buyNow": true,
        "makeOffer": true,
        "shipping": { "us": { "amount": 17, "enabled": true } },
        "seller": {
            "id": 1906846,
            "username": "RAROV",
            "ratingAverage": 4.85,
            "ratingCount": 943,
            "totalBoughtAndSold": 2614,
            "trustedSeller": false
        },
        "createdAt": "2026-06-10T12:42:40.000Z"
    }
]
````

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**.

### 📋 Data Fields

| Field                                                    | Description                                               |
| -------------------------------------------------------- | --------------------------------------------------------- |
| `id` / `url`                                             | Listing ID and direct link on Grailed.                    |
| `title`                                                  | Listing title.                                            |
| `designer` / `designers`                                 | Brand / designer name(s).                                 |
| `department`, `category`, `categoryPath`                 | Menswear/womenswear and item category.                    |
| `size`, `condition`, `color`, `styles`                   | Item attributes.                                          |
| `price`, `priceDrops`                                    | Current asking price and price-drop history.              |
| `sold`, `soldPrice`, `soldAt`                            | Sale status, final sold price, and sold date (sold mode). |
| `strata`                                                 | Listing tier (hype / grailed / basic).                    |
| `location`, `shipping`                                   | Seller location and per-region shipping rates.            |
| `coverPhoto`, `photoCount`, `measurementCount`           | Primary image and counts.                                 |
| `seller`                                                 | Seller username, rating, review count, and trade volume.  |
| `createdAt`                                              | When the listing was posted.                              |
| `description`, `photos`, `measurements`, `sellerProfile` | Added when **Scrape full details** is enabled.            |

### 💵 Pricing

This Actor uses the **pay-per-event** pricing model — you only pay for what you scrape:

| Event                  | Price    | When it's charged                                    |
| ---------------------- | -------- | ---------------------------------------------------- |
| Actor start            | $0.00005 | Once per run.                                        |
| Listing scraped        | $0.005   | Per listing when **Scrape full details** is off.     |
| Listing detail scraped | $0.01    | Per listing when **Scrape full details** is enabled. |

Each listing is charged once — either the cheaper listing fee or, when full details are enabled, the detail fee (never both). A default run of 50 listings costs about **$0.25**; with full details, about **$0.50**. New Apify accounts include **free monthly usage credits**, so you can try it at no cost.

### 💡 Tips

- Start with a small `maxItems` to preview the data shape before scaling up.
- Use **sold-only mode** to build price-history datasets and sold comps for resellers.
- Combine `department`, `minPrice`, and `maxPrice` to target a precise market segment.
- Schedule runs to track price drops and new listings for specific brands over time.

### ❓ FAQ

**Is scraping Grailed legal?**
This Actor collects only publicly available listing data. You are responsible for using the data in compliance with Grailed's Terms of Service and applicable laws. Avoid collecting personal data beyond public seller profile fields.

**Can I scrape sold prices?**
Yes — enable **Sold listings only** to retrieve final sale prices and dates.

**How many listings can I scrape?**
Set `maxItems` to control the volume. The scraper paginates automatically to collect large result sets.

### 🆘 Support

Found a bug or need a custom data field? Open an issue from the Actor's **Issues** tab and we'll take a look. Custom scraping solutions are also available on request.

Optimize your resale strategy with the **Grailed Listings Scraper** today! 🚀

# Actor input Schema

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

Keyword to search Grailed for, e.g. a brand, designer, or item type.

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

Paste Grailed search or designer page URLs to scrape instead of (or in addition to) the search query.

## `department` (type: `string`):

Limit results to a department.

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

Scrape SOLD listings (with their final sold price and date) instead of live ones — ideal for price-history and market analysis.

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

Only include listings priced at or above this amount.

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

Only include listings priced at or below this amount.

## `scrapeDetails` (type: `boolean`):

Fetch the full description, all photos, measurements, and complete seller profile for each listing. Slower and adds cost, so it is off by default.

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

Maximum number of listings to scrape.

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

Select proxies to be used by the scraper.

## Actor input object example

```json
{
  "searchQuery": "nike",
  "department": "all",
  "soldOnly": false,
  "scrapeDetails": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "nike"
};

// Run the Actor and wait for it to finish
const run = await client.actor("piotrv1001/grailed-listings-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 = { "searchQuery": "nike" }

# Run the Actor and wait for it to finish
run = client.actor("piotrv1001/grailed-listings-scraper").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 '{
  "searchQuery": "nike"
}' |
apify call piotrv1001/grailed-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Grailed Listings Scraper",
        "description": "The Grailed Listings Scraper extracts listings from Grailed's marketplace — capturing titles, designers, prices, price drops, sizes, conditions, colors, photos, shipping rates, sold prices, and seller ratings — ideal for resale price tracking, sold-comp research, and fashion market analytics.",
        "version": "0.0",
        "x-build-id": "758lUH7mACZMct9qD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piotrv1001~grailed-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piotrv1001-grailed-listings-scraper",
                "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/piotrv1001~grailed-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-piotrv1001-grailed-listings-scraper",
                "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/piotrv1001~grailed-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-piotrv1001-grailed-listings-scraper",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search Grailed for, e.g. a brand, designer, or item type."
                    },
                    "startUrls": {
                        "title": "Grailed URLs (optional)",
                        "type": "array",
                        "description": "Paste Grailed search or designer page URLs to scrape instead of (or in addition to) the search query.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "department": {
                        "title": "Department",
                        "enum": [
                            "all",
                            "menswear",
                            "womenswear"
                        ],
                        "type": "string",
                        "description": "Limit results to a department.",
                        "default": "all"
                    },
                    "soldOnly": {
                        "title": "Sold listings only",
                        "type": "boolean",
                        "description": "Scrape SOLD listings (with their final sold price and date) instead of live ones — ideal for price-history and market analysis.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings priced at or above this amount."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings priced at or below this amount."
                    },
                    "scrapeDetails": {
                        "title": "Scrape full details",
                        "type": "boolean",
                        "description": "Fetch the full description, all photos, measurements, and complete seller profile for each listing. Slower and adds cost, so it is off by default.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by the scraper.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
