# Sneaker Release Dates Scraper (`sheshinmcfly/sneaker-release-scraper`) Actor

Track upcoming sneaker releases from SoleRetriever. Filter by brand (Nike, Jordan, adidas, New Balance, Puma, Vans, Saucony, Crocs) and date range. Returns name, SKU, brand, release date, days until drop, product image, and direct retailer link.

- **URL**: https://apify.com/sheshinmcfly/sneaker-release-scraper.md
- **Developed by:** [Sheshinmcfly](https://apify.com/sheshinmcfly) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Sneaker Release Dates Scraper

Track **upcoming sneaker releases** from [SoleRetriever](https://www.soleretriever.com) — one of the most comprehensive sneaker release calendars on the internet.

Filter by brand, date range, and export structured data with release dates, SKUs, images, and direct product URLs. Updated daily.

---

### What data does it extract?

| Field | Description | Example |
|---|---|---|
| `name` | Full sneaker name | `"Air Jordan 4 Retro Iced Carmine (W)"` |
| `brand` | Brand name | `"Air Jordan"` |
| `sku` | Style code / SKU | `"IB6716-600"` |
| `releaseDate` | Official release date | `"2026-04-23"` |
| `daysUntilRelease` | Days from today | `2` |
| `category` | Product category | `"sneakers"` |
| `description` | Short description | `"Air Jordan 4 Retro..."` |
| `imageUrl` | Product image URL | `"https://images.soleretriever.com/..."` |
| `url` | SoleRetriever product page | `"https://www.soleretriever.com/..."` |
| `extractedAt` | Extraction timestamp | `"2026-04-21T12:00:00Z"` |

---

### Use cases

- **Resellers & flippers**: Stay ahead of hyped drops — know what's releasing before it sells out
- **Price monitoring**: Track retail prices for upcoming releases to plan buy/sell strategies
- **Sneaker bots**: Feed release data into automation systems for early checkout
- **Market research**: Analyze brand release frequency and product categories
- **Retail planning**: For sneaker boutiques tracking upcoming inventory
- **Collectors**: Never miss a release from your favorite brand

---

### Supported brands

Nike, Air Jordan, adidas, New Balance, Puma, Vans, Saucony, Crocs, ASICS, Reebok — plus hundreds more.

---

### How to use

1. Open the actor and configure:
   - **Brands**: Select specific brands or "All brands"
   - **Days ahead**: Only get releases within the next N days (30 = next month)
   - **Max results**: Cap the total number of releases
   - **Include images**: Whether to include product image URLs
2. Click **Start**
3. Download results as JSON, CSV, or Excel

---

### Example output (JSON)

```json
{
  "name": "Air Jordan 4 Retro Iced Carmine (W)",
  "brand": "Air Jordan",
  "sku": "IB6716-600",
  "releaseDate": "2026-04-23",
  "daysUntilRelease": 2,
  "category": "sneakers",
  "description": "Air Jordan 4 Retro Iced Carmine (W) Air Jordan Air Jordan 4",
  "imageUrl": "https://images.soleretriever.com/sb/products/...",
  "url": "https://www.soleretriever.com/sneaker-release-dates/jordan/air-jordan-4-retro-iced-carmine-w-ib6716-600",
  "extractedAt": "2026-04-21T12:00:00.000Z"
}
````

***

### Pricing

This actor charges **$0.002 USD per sneaker extracted**. Extracting 100 upcoming releases costs approximately $0.20 USD.

***

### Keywords

sneaker release dates scraper, upcoming sneaker drops, Jordan release calendar, Nike drop dates, adidas release schedule, sneaker release tracker, hype sneaker calendar, SoleRetriever scraper, sneaker resell data, sneaker drop alert

***

### Legal Disclaimer

This actor extracts **publicly available commercial data only** from SoleRetriever (soleretriever.com), in compliance with Chilean Law 19.628 on the Protection of Private Life (*Ley 19.628 sobre Protección de la Vida Privada*).

**What this actor does NOT collect:**

- Names or personal data of any individuals
- User accounts, purchase history, or private information
- Any data that could identify or profile a private person

**What this actor collects:**

- Product names, SKUs, and release dates (public commercial data)
- Brand names and product categories
- Product images and URLs (publicly accessible metadata)

The data extracted is identical to what any visitor can freely view on the SoleRetriever website. Users are solely responsible for ensuring their use of this data complies with applicable laws and the website's terms of service.

# Actor input Schema

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

Select which brands to monitor. Leave empty to get all brands.

## `maxDaysAhead` (type: `integer`):

Only return releases within the next N days. 0 = no limit.

## `maxResults` (type: `integer`):

Maximum number of sneakers to extract.

## `includeImages` (type: `boolean`):

Include product image URLs in the output.

## Actor input object example

```json
{
  "brands": [
    "all"
  ],
  "maxDaysAhead": 30,
  "maxResults": 100,
  "includeImages": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped sneaker releases stored in the default dataset.

# 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("sheshinmcfly/sneaker-release-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("sheshinmcfly/sneaker-release-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 '{}' |
apify call sheshinmcfly/sneaker-release-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sneaker Release Dates Scraper",
        "description": "Track upcoming sneaker releases from SoleRetriever. Filter by brand (Nike, Jordan, adidas, New Balance, Puma, Vans, Saucony, Crocs) and date range. Returns name, SKU, brand, release date, days until drop, product image, and direct retailer link.",
        "version": "1.0",
        "x-build-id": "mieTalV2xTOjnaFMH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sheshinmcfly~sneaker-release-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sheshinmcfly-sneaker-release-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/sheshinmcfly~sneaker-release-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sheshinmcfly-sneaker-release-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/sheshinmcfly~sneaker-release-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sheshinmcfly-sneaker-release-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": {
                    "brands": {
                        "title": "Brands to track",
                        "type": "array",
                        "description": "Select which brands to monitor. Leave empty to get all brands.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "all",
                                "jordan",
                                "nike",
                                "adidas",
                                "new-balance",
                                "puma",
                                "vans",
                                "saucony",
                                "crocs",
                                "asics",
                                "reebok"
                            ],
                            "enumTitles": [
                                "All brands",
                                "Air Jordan",
                                "Nike",
                                "adidas",
                                "New Balance",
                                "Puma",
                                "Vans",
                                "Saucony",
                                "Crocs",
                                "ASICS",
                                "Reebok"
                            ]
                        },
                        "default": [
                            "all"
                        ]
                    },
                    "maxDaysAhead": {
                        "title": "Days ahead",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only return releases within the next N days. 0 = no limit.",
                        "default": 30
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of sneakers to extract.",
                        "default": 100
                    },
                    "includeImages": {
                        "title": "Include image URLs",
                        "type": "boolean",
                        "description": "Include product image URLs in the output.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
