Grailed Marketplace Scraper: 17 Data Fields per Record (2026)

Each record carries 17 output fields, covering price in USD, designer names, condition, photo URLs, seller username, and direct listing links. The free-plan price is $5.00 per 1,000 results, and the input schema offers 8 controls with 0 required. Both active inventory and sold listings appear, identifiable by the presence of a soldAt timestamp. This scraper is built for fashion resellers, price analysts, and buyers monitoring streetwear releases. It is not for teams requiring seller contact details like email addresses or phone numbers, which Grailed records do not provide.

Try it: open Grailed Marketplace Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try Grailed Marketplace Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Grailed Marketplace Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 20, so a first run returns at most 20 results and costs at most $0.10 in result charges. That is enough to see the real shape of the data before deciding anything.

Grailed Marketplace Scraper was last updated on 2026-06-02. It is one of 1,724 Actors CrawlerBros publishes on Apify, which together have 728,502 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Grailed Marketplace Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The primary cost driver is maxItems because result charges scale directly with the number of records written to your dataset. Running a quick verification with the prefilled maxItems of 20 keeps your first-run result charge capped at $0.10 while validating your query parameters.

How do you run Grailed Marketplace Scraper from the API?

None of its 8 controls is strictly required, so the defaults below produce a valid run on their own. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Grailed Marketplace Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~grailed-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery":"supreme","maxItems":20}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "searchQuery": "supreme",
  "maxItems": 20
}

run = client.actor("crawlerbros~grailed-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "searchQuery": "supreme",
  "maxItems": 20
}

const run = await client.actor('crawlerbros~grailed-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Grailed Marketplace Scraper inputs matter, and which can you skip?

The main controls shaping your output are searchQuery, designerName, and category. You can leave condition, minPrice, and maxPrice blank initially until you confirm that broader keyword queries return the items you expect.

• searchQuery (string): Keyword to search for (e.g. "Supreme hoodie", "Yeezy 350", "Rick Owens jacket").
• category (string): Filter listings by clothing category.
• designerName (string): Filter by designer or brand name (e.g. "Supreme", "Off-White", "Yeezy").
• minPrice (integer): Only return listings priced at or above this amount (in USD).
• maxPrice (integer): Only return listings priced at or below this amount (in USD).
• size (string): Size filter (e.g. "M", "L", "XL", "32", "10").
• condition (string): Filter by item condition.
• maxItems (integer): Maximum number of listings to return. Default: 20.

Fixed-choice controls: category accepts tops, bottoms, footwear, outerwear, tailoring, accessories; condition accepts is_new (New / Not worn (deadstock)), is_gently_used (Gently used), is_used (Used), is_worn (Worn).

What does Grailed Marketplace Scraper return?

The returned records provide listing metadata, categorized taxonomy, seller usernames, locations, and timestamps for tracking fashion resale trends. They do not contain private seller contact details, buyer identities, or payment transaction logs.

• listingId: String - Unique Grailed listing ID
• title: String - Listing title
• designerNames: Array - Designer/brand names (e.g. ["Supreme"])
• category: String - Top-level category (e.g. "tops")
• subCategory: String - Subcategory (e.g. "hoodies")
• size: String - Item size
• condition: String - Item condition
• price: Number - Price in USD
• currency: String - Currency code (typically "USD")
• description: String - Listing description from seller
• photoUrls: Array - Photo URLs
• sellerUsername: String - Grailed username of the seller
• sellerLocation: String - Seller's location
• soldAt: String - ISO 8601 timestamp if item was sold (omitted if unsold)
• listedAt: String - ISO 8601 timestamp when the listing was created
• sourceUrl: String - Direct URL to the Grailed listing
• scrapedAt: String - ISO 8601 timestamp when the data was scraped

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Grailed Marketplace Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run a test query with searchQuery set to a specific item such as Supreme Box Logo Hoodie, maxItems set to 5, and leave all other fields blank.
2. Inspect the returned dataset items to verify that listingId, price, condition, and sourceUrl populated correctly.
3. Add designerName matching the target label, such as Supreme or Rick Owens, and set category to narrow the scope to tops, bottoms, outerwear, footwear, tailoring, or accessories.
4. Apply minPrice, maxPrice, and size filters to restrict the result set to the exact inventory bracket you need.
5. If item wear matters for your pricing model, configure condition using is_new, is_gently_used, is_used, or is_worn.
6. Increase maxItems up to the 500 ceiling for your production extraction run.
7. Filter your output downstream on the presence or absence of soldAt to separate active listings from historical sales.

How do you apply it? Three worked playbooks

These are Grailed Marketplace Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Streetwear price tracking

Outcome: Streetwear price tracking: Monitor going rates for Supreme drops, Nike SB collabs, or Palace items

Configure: Set searchQuery to "Supreme Box Logo Hoodie", category to "tops", and maxItems to 100.

Working method: Execute the run on a recurring schedule to pull current marketplace listings, isolate records without a soldAt field for active asking prices, and compute the rolling median price.

Deliverable: A structured dataset of asking prices, seller locations, and condition tiers for current streetwear inventory.

Stop condition: Stop if median price calculation fails due to missing or null price fields across returned items.

Use case 2: Designer resale research

Outcome: Designer resale research: Analyze secondhand market pricing for luxury brands

Configure: Set designerName to "Rick Owens", category to "outerwear", condition to "is_gently_used", and maxItems to 250.

Working method: Extract listings across multiple apparel categories for the designer, then group records by subCategory and condition to establish baseline luxury resale values.

Deliverable: A comparative valuation table segmenting average resale prices by garment type and wear condition.

Stop condition: Stop if returned designerNames entries do not match the requested designer query.

Use case 3: Deal hunting

Outcome: Deal hunting: Find underpriced listings before they sell

Configure: Set searchQuery to "Yeezy 350", category to "footwear", size to "10", maxPrice to 150, and maxItems to 50.

Working method: Poll the marketplace frequently with tight price ceilings, filtering for active listings created within the last 24 hours based on listedAt.

Deliverable: An immediate alert feed of active listings priced below target thresholds with direct sourceUrl links.

Stop condition: Stop if items returned have prices exceeding the configured maxPrice ceiling.

What breaks, and how do you design around it?

Each individual run caps output at 500 listings via maxItems. When collecting larger historical catalogs, partition your collection into multiple targeted runs using distinct size, category, or price range filters.

When should you not use Grailed Marketplace Scraper?

Do not use this scraper if you require primary retail catalog data from authorized luxury fashion boutiques rather than a peer-to-peer resale marketplace. When tracking verified brand-new luxury inventory with structured multi-brand retailer metadata, use Mytheresa Luxury Fashion Scraper. If your focus is certified pre-owned vintage luxury handbags and accessories from a curated business retailer rather than individual Grailed sellers, use WGACA Luxury Vintage Resale Scraper.

What should you check before trusting the output?

• Verify price is a positive integer or float and currency equals USD.
• Check that designerNames contains at least one non-empty string entry per record.
• Confirm sourceUrl begins with https://www.grailed.com/listings/ and contains the matching listingId.
• Ensure condition matches one of the expected schema values: is_new, is_gently_used, is_used, or is_worn.
• Halt downstream pipeline if photoUrls returns an empty array across all retrieved records.

None of this proves a record is correct. It gives a scheduled Grailed Marketplace Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What is the pricing for running Grailed Marketplace Scraper?

On Apify's free plan, the scraper costs $5.00 per 1,000 results, which works out to $0.005 per result. Paid Apify tiers pay lower result rates. Apify also bills platform usage consumed by the run, and a memory run-start fee is charged whenever a run executes regardless of whether results are found.

How do I distinguish between active listings and items that have sold?

Check the soldAt output field. If an item has been purchased, the record contains an ISO 8601 timestamp in soldAt. Active, unsold listings omit the soldAt field entirely, letting you filter current inventory from historical sales.

Can I filter Grailed listings by designer and keyword at the same time?

Yes. The searchQuery and designerName controls apply simultaneously. For example, you can set searchQuery to hoodie and designerName to Supreme to isolate hooded sweatshirts from that specific brand without pulling other garment types.

What is the maximum number of items I can scrape in a single run?

The maxItems input allows up to 500 listings per run. If your target market holds more than 500 items, split your collection across separate runs by segmenting with category, size, or price brackets.

Does the dataset include direct links to product photos?

Yes. Every record includes a photoUrls array containing direct URLs to all product images uploaded by the seller, along with sourceUrl linking directly to the listing page on Grailed.

Where to go next

When you are ready to run it, open Grailed Marketplace Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Grailed Marketplace Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• WGACA Luxury Vintage Resale Scraper: Scrape What Goes Around Comes Around (WGACA) - a luxury vintage/pre-owned designer resale retailer.
• Mytheresa Luxury Fashion Scraper: Scrape luxury fashion product listings from Mytheresa.com - one of the world's leading multi-brand luxury retailers.
• Ounass Scraper: Scrape Ounass (ounass.ae) - luxury fashion e-commerce for the UAE and GCC.
• LimeRoad Scraper: Scrape LimeRoad.com - India's multi-brand fashion marketplace for women, men, kids and home.
• Pamono Vintage & Antique Design Scraper: Scrape pamono.com - the leading marketplace for vintage, antique, and contemporary design.
• Zalora Fashion Scraper: Scrape Zalora with Southeast Asia's leading fashion and lifestyle marketplace.
• Reverb Music Gear Marketplace Scraper: Scrape Reverb.com the world's largest music gear marketplace.
• PrettyLittleThing Fashion Scraper: Scrape prettylittlething.com fashion products.

Related guides:

• Mytheresa Luxury Fashion Scraper: 24 Data Fields per Record (2026)
• 1stDibs Scraper: 24 Data Fields, Up to 1,000 Free Results/Month (2026)
• The RealReal Scraper: Up to 1,000 Free Results a Month (2026)
• Chairish Scraper: 21 Data Fields, Up to 1,000 Free Results/Month

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-03.

• Actor last updated by its maintainers on 2026-06-02.

• Run outcome figures cover the 30 day public window ending 2026-10-03.

• Grailed Marketplace Scraper on Apify