# ASOS Scraper — Fashion Product Data, Prices & New-In Tracking (`haketa/asos-scraper`) Actor

Scrape ASOS fashion products by category: product names, brands, current and previous prices, discount amounts, colours, product and image links, plus new-in and selling-fast signals for price monitoring, competitor assortment research and trend tracking across the US and UK stores. Exports JSON.

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

## Pricing

from $1.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

<div align="center">

## ASOS Scraper — Fashion Product Data, Prices & New-In Tracking

**Collect ASOS fashion products as clean, structured data — product names, brands, current and previous prices, discounts, colours, product and image links, plus new-in and selling-fast signals for price monitoring and trend research.**

![ASOS](https://img.shields.io/badge/ASOS-Fashion%20Products-black?style=for-the-badge)
![Apify Actor](https://img.shields.io/badge/Apify-Actor-97C93F?style=for-the-badge)
![Export](https://img.shields.io/badge/Export-JSON%20%C2%B7%20CSV%20%C2%B7%20Excel-blue?style=for-the-badge)
![No Code](https://img.shields.io/badge/No%20Code-Required-purple?style=for-the-badge)

</div>

***

### 📑 Contents

- [At a glance](#-at-a-glance)
- [What this ASOS scraper does](#-what-this-asos-scraper-does)
- [Key features](#-key-features)
- [Who it is for](#-who-it-is-for)
- [Use cases](#-use-cases)
- [How it works](#-how-it-works)
- [Step-by-step usage](#-step-by-step-usage)
- [Input](#-input)
- [Output](#-output)
- [Proven results (local verification)](#-proven-results-local-verification)
- [Integrations](#-integrations)
- [Tips for better results](#-tips-for-better-results)
- [Limitations](#-limitations)
- [FAQ](#-faq)
- [Keywords](#-keywords)
- [Disclaimer](#-disclaimer)

***

### ⚡ At a glance

| | |
|---|---|
| **What you collect** | ASOS products: name, brand, prices, discount, colour, product & image links |
| **Browse by** | Built-in popular categories, your own category links, or raw category IDs |
| **Stores** | United States (USD) or United Kingdom (GBP) |
| **Key fields** | Current / previous price, discount %, selling-fast & new flags, category, store |
| **Empty run** | Still returns about 110 products across popular categories |
| **Output formats** | JSON, CSV, Excel, HTML and XML via the Apify Console export |
| **Code required** | None — pick a category and press Start |
| **Typical run** | 100 products in under a minute; full categories scale to thousands |

***

### 👗 What this ASOS scraper does

ASOS lists tens of thousands of fashion products across women's and men's
departments, and the catalogue turns over constantly: new-in drops land
daily, prices move, and popular pieces sell fast. Browsing that by hand —
opening category after category and copying names, prices and links into
a spreadsheet — does not scale, and by the time you finish, the prices
have already changed.

This **ASOS scraper** turns category browsing into a dataset you can
actually work with. Pick a department (or paste your own category links),
choose the US or UK store, and it returns one clean record per product
with the details that matter:

- what it is (**name**, **brand**, **colour**, **product type**),
- what it costs (**current price**, **previous price**, **discount %**,
  **currency**),
- how it is moving (**selling-fast**, **new**, **promotion** and
  **restocking** signals),
- and direct links back to the **product page** and **product images**.

Whether you are running **price monitoring** on a competitor range,
mapping a category for **assortment research**, or tracking **new-in
trends** week after week, this actor gives you the raw material in
minutes instead of days of manual browsing.

***

### ✨ Key features

- **Popular categories built in** — twelve women's and men's departments
  ready to browse, from New In and Dresses to Shoes and Jackets & Coats.
- **Mixed sample in one click** — "All popular categories" spreads a
  sample across departments, so one run shows you the whole shop floor.
- **Your own categories, too** — paste ASOS category page links or raw
  category IDs to collect niche departments, sale pages and brand ranges
  outside the built-in list.
- **Two stores, correct money** — United States (USD) or United Kingdom
  (GBP); prices, currency and product links always match the store you
  picked.
- **Discounts worked out for you** — previous price and discount percent
  are captured whenever a product is marked down, ready for filtering.
- **Demand signals included** — selling-fast, new, promotion and
  restocking flags travel with every record, so you can spot what is
  moving without opening each product page.
- **Optional keyword narrowing** — filter inside the browsed categories
  by words matched against name, brand and colour (for example "leather"
  or a brand name).
- **Works with an empty form** — press Start without changing anything
  and still get about 110 products to explore.
- **Clean, analysis-ready records** — consistent field names, duplicates
  removed, and empty values left out instead of cluttering your export.
- **Export anywhere** — download JSON, CSV or Excel, or send results to
  your stack with Apify integrations and the API.

***

### 👥 Who it is for

- **Fashion buyers and merchandisers** mapping competitor ranges and
  spotting assortment gaps.
- **E-commerce and DTC brands** monitoring ASOS prices on overlapping
  products and categories.
- **Price-monitoring and repricing teams** who need repeatable price
  snapshots instead of manual checks.
- **Trend and content researchers** tracking what is new, what is selling
  fast, and which brands dominate a department.
- **Data analysts** building fashion datasets, price indices and market
  dashboards.
- **Students and curious builders** who want a real, explorable sample of
  a live fashion catalogue without writing code.

***

### 💡 Use cases

#### 1. Monitor competitor prices in a category

Pick the department you compete in (for example Dresses), run the actor
on a schedule, and compare `priceCurrent` week over week. Marked-down
products surface through `isMarkedDown` and `discountPercent`, so price
moves and promotions are visible without opening hundreds of pages.

#### 2. Map a full category for assortment research

Choose one department, raise **Max results** (or set it to `0`), and
export the full range: brands, colours, price bands and product types.
A single Dresses export can run to thousands of products — enough to
analyse price architecture and brand share properly.

#### 3. Track new-in and selling-fast momentum

Run **Women — New In** or **Men — New In** regularly and watch the
`isSellingFast` flag. Products that appear as new and quickly turn
selling-fast are the demand signal buyers and content teams care about.

#### 4. Compare the US and UK stores

Run the same category once per store and compare prices, currency and
range side by side. Useful for international pricing research and for
spotting products listed in one market but not the other.

#### 5. Build a brand watchlist

Browse the categories a brand sells in, narrow with the keyword filter
set to the brand name, and export its live range with prices and links.
Repeat on a schedule to catch new drops and price changes.

#### 6. Feed a price index or dashboard

Run the actor via the Apify API or on a schedule and pipe the dataset
into your warehouse, BI tool or internal search. Consistent fields
across runs make week-over-week comparisons straightforward.

#### 7. Support academic and market research

Build a citable snapshot of a fashion catalogue at a point in time:
counts by brand, category and colour, price distributions, and discount
depth — all from one export instead of manual sampling.

***

### ⚙️ How it works

1. **You describe what you want** — pick a category (or paste your own
   category links), choose the US or UK store, and optionally add
   keywords.
2. **The actor browses those categories** page by page (48 products per
   page), spreading a capped sample across departments when you ask for
   a mixed run.
3. **Records are tidied as they arrive** — duplicates are removed,
   discounts are calculated, and each product gets direct links to its
   page and images.
4. **You get a dataset** in the Apify Console: preview it in the table,
   filter it, and export it as JSON, CSV or Excel — or pull it through
   the API.

No setup, no scripts and nothing to maintain on your side. If you leave
every field as it is, the actor simply collects a mixed sample of about
110 products so you can see the output shape right away.

***

### 🚀 Step-by-step usage

1. Open the actor in the Apify Console and go to the **Input** tab.
2. Choose a **Category** — "All popular categories" is a good first run.
3. Choose the **Store / country**: United States (USD) or United
   Kingdom (GBP).
4. (Optional) Add **Filter keywords** to narrow inside the categories,
   for example `leather` or a brand name.
5. (Advanced, optional) Paste your own category links in **Start URLs**
   or raw IDs in **Custom category IDs** to browse exactly those ranges.
6. Set **Max results** to the size you want (110 is the default sample).
7. Press **Start** and watch the live log and status counter.
8. When the run finishes, open the **Dataset** tab to preview records.
9. Use **Export** to download JSON, CSV or Excel — or open the
   **Integrations** tab to send data onward automatically.
10. Re-run any time; try scheduling weekly runs to build a time series.

***

### 📥 Input

Every field is optional. Start with the defaults, then narrow down.

| Field | What it does | Example |
|---|---|---|
| **Category** | Built-in department to browse, or a mixed sample | `all` |
| **Store / country** | US store in USD or UK store in GBP | `US` |
| **Filter keywords** | Optional words matched against name, brand and colour | `leather` |
| **Start URLs** | Your own ASOS category page links (advanced) | a category page link |
| **Custom category IDs** | Raw `cid` values from category page addresses (advanced) | `8799` |
| **Max results** | Cap on products collected; `0` means no cap | `100` |
| **Max pages per category** | How deep to paginate inside each category | `20` |
| **Proxy configuration** | Connection settings; the default is right for most runs | default |

#### Example 1 — Instant mixed sample (zero setup)

```json
{}
```

Returns about 110 products spread across the popular categories.

#### Example 2 — One department in depth

```json
{
  "category": "8799",
  "store": "US",
  "maxItems": 500
}
```

Collects 500 dresses from the US store.

#### Example 3 — UK store price check

```json
{
  "category": "4209",
  "store": "GB",
  "maxItems": 200
}
```

Collects men's shoes, boots and sneakers with GBP prices.

#### Example 4 — Your own category link

```json
{
  "startUrls": ["https://www.asos.com/women/sale/dresses/cat/?cid=5235"],
  "maxItems": 300
}
```

Collects exactly the category behind the pasted link. Any ASOS category
page link containing `cid=` works.

#### Example 5 — Keyword narrowing inside categories

```json
{
  "category": "all",
  "keywords": ["leather"],
  "maxItems": 200
}
```

Keeps only products whose name, brand or colour matches "leather"
within the browsed categories.

<details>
<summary>Example 6 — Full category export (no result cap)</summary>

```json
{
  "category": "8799",
  "store": "US",
  "maxItems": 0,
  "maxPagesPerCategory": 100
}
```

Walks the whole Dresses category page by page. Large categories hold
thousands of products, so expect a longer run — raise **Max pages per
category** together with **Max results** when you go deep.

</details>

***

### 📤 Output

Each run produces one record per ASOS product. Field names stay the
same across categories and stores, so exports are easy to combine and
compare. Empty values are simply left out of a record — a product that
is not marked down, for example, carries no previous-price fields
instead of blank ones.

**Coverage legend** (from the local verification runs below):
🟢 present for nearly every record · 🟡 present when the product
provides it · ⚪ present for a smaller share of records.

#### Product identity

| Field | Meaning | Coverage |
|---|---|---|
| `productId` | ASOS product identifier | 🟢 every record |
| `name` | Product name as listed | 🟢 every record |
| `brandName` | Brand, e.g. `ASOS DESIGN` | 🟢 every record |
| `colour` | Colourway, e.g. `GREEN` | 🟢 every record |
| `productType` | Product type as classified by ASOS | 🟢 every record |
| `productCode` | Internal product code | 🟢 every record |
| `colourWayId` | Colourway identifier | 🟢 every record |

#### Price & discount

| Field | Meaning | Coverage |
|---|---|---|
| `priceCurrent` | Current price (number) | 🟢 every record |
| `priceCurrentText` | Current price as displayed, e.g. `$86.99` | 🟢 every record |
| `currency` | `USD` or `GBP`, matching the store | 🟢 every record |
| `pricePrevious` | Price before markdown (number) | 🟡 only on marked-down products |
| `pricePreviousText` | Previous price as displayed | 🟡 only on marked-down products |
| `discountPercent` | Markdown depth in percent | 🟡 only on marked-down products |
| `isMarkedDown` | Whether the product is currently discounted | 🟢 every record |

#### Links & media

| Field | Meaning | Coverage |
|---|---|---|
| `productUrl` | Direct link to the product page | 🟢 every record |
| `imageUrl` | Main product image | 🟢 every record |
| `additionalImageUrls` | Further product images | 🟢 every record |
| `videoUrl` | Catwalk / product video when available | 🟡 about half of records |

#### Demand signals & provenance

| Field | Meaning | Coverage |
|---|---|---|
| `isSellingFast` | ASOS selling-fast signal | 🟢 every record (true on a majority of new-in stock) |
| `isNew` | New-in signal | 🟢 every record |
| `isRestockingSoon` | Restocking signal | 🟢 every record |
| `isPromotion` | Promotion signal | 🟢 every record |
| `hasVariantColours` | Whether other colourways exist | 🟢 every record |
| `categoryId` | Category browsed (`cid`) | 🟢 every record |
| `categoryName` | Category name, e.g. `Dresses` | 🟢 every record |
| `store` | `US` or `GB` | 🟢 every record |
| `scrapedAt` | When this actor collected the record | 🟢 every record |

#### Example output record

```json
{
  "productId": 210817933,
  "name": "Aria Cove oversized collar faux Mongolian fur cropped jacket in green",
  "brandName": "Aria Cove",
  "colour": "GREEN",
  "productType": "Product",
  "priceCurrent": 191,
  "priceCurrentText": "$191.00",
  "currency": "USD",
  "isMarkedDown": false,
  "productUrl": "https://www.asos.com/us/aria-cove/aria-cove-oversized-collar-faux-mongolian-fur-cropped-jacket-in-green/prd/210817933",
  "imageUrl": "https://images.asos-media.com/products/aria-cove-oversized-collar-faux-mongolian-fur-cropped-jacket-in-green/210817933-1-green",
  "isSellingFast": true,
  "isNew": false,
  "categoryId": 27108,
  "categoryName": "New in",
  "store": "US",
  "scrapedAt": "2026-10-23T13:43:08.527Z"
}
```

***

### ✅ Proven results (local verification)

This actor was run locally before release. All numbers below are from
those real runs — same code, same output shape you will receive.

| Check | Input | Result |
|---|---|---|
| Empty run | `{}` (nothing changed at all) | **110 products** spread across popular categories |
| Live category size | Women — Dresses (`8799`), US store | **16,523 products** in the category |
| Live category size | Women — New In (`27108`), US store | **7,746 products** in the category |
| Live category size | Men — Shoes (`4209`), US store | **1,569 products** in the category |
| Pagination | 48 products per page, offset stepping | Verified page after page with deduplication |

Field fill highlights from the empty run (110 records):

- Identity, price and links were complete: `productId`, `name`,
  `brandName`, `colour`, `priceCurrent`, `currency`, `productUrl`,
  `imageUrl` and `scrapedAt` appeared on every record.
- Prices were real catalogue prices (sample range $22.99–$509.00 in
  the US store) — nothing padded or invented.
- Demand signals were present on every record; `isSellingFast` was
  true on 68 of 110 new-in-heavy records.
- Discount fields (`pricePrevious`, `discountPercent`) appear only on
  marked-down products by design. A New In sample is mostly full-price,
  so expect them mainly in sale and outlet categories.
- Sample product and image links were opened and answered
  successfully.

What this means for you: the core columns you will filter and sort on
arrive filled. Discount columns reflect what is actually on sale —
nothing is padded with invented values. A single large category
(Dresses, 16K+ products) already exceeds ten thousand records, and a
full multi-category export goes well beyond that.

***

### 🔌 Integrations

Because results live in a standard Apify dataset, they flow into the
tools you already use:

- **Spreadsheets** — export CSV or Excel, or connect Google Sheets to
  refresh a price workbook on a schedule.
- **Databases & warehouses** — pull the dataset through the Apify API
  into Postgres, BigQuery, Snowflake or your internal catalogue.
- **Automation platforms** — trigger Make, Zapier or n8n workflows when
  a scheduled run finishes (for example: "price drop in Dresses").
- **Chat alerts** — post a Slack or email digest of new selling-fast
  products after each run.
- **BI dashboards** — feed Looker Studio, Tableau or Power BI from the
  exported data for an always-current assortment view.
- **Custom code** — call the actor from the Apify API / SDKs in your
  own pipeline and read structured JSON back.

A typical pattern: schedule the actor weekly per category, then let an
automation diff prices and flag the biggest movers.

***

### 💡 Tips for better results

- **Start with the mixed sample.** Run "All popular categories" first
  to see the output shape, then go deep on one department.
- **Match the store to the question.** Prices, currency and links all
  follow the store — pick US or GB deliberately, not by habit.
- **Use keywords to narrow, not to search the whole site.** The keyword
  filter works inside the categories you browse; for a niche range,
  pasting its category link is more precise.
- **Hunt discounts in the right place.** Previous prices and discount
  percent only exist on marked-down stock — browse sale and outlet
  categories when discounts are the point.
- **Raise both caps together.** **Max results** and **Max pages per
  category** work as a pair; deep exports need both lifted.
- **Keep runs comparable.** Same input on a schedule gives you a clean
  time series; changing inputs mid-series breaks comparisons.
- **Sort after export.** Order by `priceCurrent`, `discountPercent` or
  the selling-fast flag in your spreadsheet or warehouse — the actor
  keeps ASOS's own category order.

***

### ⚠️ Limitations

- **Category browsing, not site search.** The actor collects what
  category listings show. The keyword filter narrows inside those
  categories; it is not a full-site search engine.
- **Listing-level data.** Records carry the price, colour and signals
  shown in listings. Size-level stock and full product descriptions
  live on each product page — follow `productUrl` when you need them.
- **Discounts mirror the catalogue.** If a product is full-price, there
  is no previous price to report. The actor never invents a discount.
- **Catalogue churn.** ASOS adds and removes products constantly —
  treat each run as a timestamped snapshot (`scrapedAt`), not a fixed
  catalogue.
- **Counts move.** Category sizes and selling-fast signals change
  through the day; re-run to refresh them.

***

### ❓ FAQ

#### Do I need an ASOS account?

No. The actor works with public category listings. Just press Start.

#### What happens if I run it with no input at all?

You still get data: about 110 products spread across the popular
women's and men's categories in the US store. It is the fastest way to
see exactly what the output looks like.

#### How do I collect a category that is not in the dropdown?

Open that category on ASOS, copy its page link (it contains `cid=`),
and paste it into **Start URLs** — or paste just the `cid` number into
**Custom category IDs**. Those categories are collected instead of the
dropdown choice.

#### What does `0` in Max results mean?

No cap for that run. The actor keeps browsing until the categories run
out or **Max pages per category** is reached. On the mixed "all"
setting that can be a very large export, so set a cap while exploring.

#### Why are previous price and discount missing on most records?

They only exist on marked-down products. New-in and full-price ranges
correctly carry no discount fields — browse sale categories to see
them filled.

#### US or UK store — which should I pick?

Pick the market you sell or research in. The US store prices in USD
and the UK store in GBP, and product links point at the matching
storefront.

#### Can I run this on a schedule and track price changes?

Yes. Schedule identical inputs (weekly works well) and compare exports
by `productId` and `scrapedAt`. New IDs are new products; changing
prices show movement.

#### Which export format should I choose?

CSV or Excel for spreadsheet work, JSON for code and pipelines. The
Console preview table is handy for a quick look and light filtering.

#### Does it collect sizes or full descriptions?

No — it collects the listing record (name, brand, prices, colour,
signals, links). Open `productUrl` for size-level detail. That keeps
runs fast and exports clean.

***

### 🔍 Keywords

ASOS scraper · ASOS product data · fashion product scraper · ASOS price
monitoring · new-in tracking · competitor assortment research · fashion
e-commerce data · ASOS dresses data · price and discount tracker ·
selling-fast signals · UK fashion data · US fashion data

***

### 📄 Disclaimer

This is an independent tool for collecting publicly available
catalogue information. **Not affiliated with ASOS.** ASOS is a
trademark of its respective owner; product and brand names appear here
only to describe what the data refers to. Please respect ASOS's terms
when using collected data.

# Actor input Schema

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

Which ASOS category to collect. Choose 'All popular categories' for a mixed sample across women's and men's departments, or pick one department to go deep on a single range.

## `store` (type: `string`):

Which ASOS store to shop from. This sets the catalogue, currency and product links: United States prices in USD, United Kingdom prices in GBP. Pick the market you sell or research in.

## `keywords` (type: `array`):

Optional words that narrow the results while browsing categories, matched against product name, brand and colour (e.g. 'leather', 'Nike', 'floral'). Leave empty to collect the full category. Note: this filters inside the browsed categories — it is not a full-site search.

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

Paste ASOS category page links (they contain 'cid=' in the address, e.g. a dresses or sneakers category page) to collect exactly those categories instead of the dropdown above. Useful for niche departments, sale pages and brand ranges outside the built-in list.

## `customCategoryIds` (type: `array`):

Advanced: raw ASOS category IDs as numbers (the 'cid' value from a category page address, e.g. 8799 for dresses). When filled, these categories are collected instead of the dropdown. Combine with Start URLs if you like — duplicates are collected once.

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

Maximum number of products to collect in total. 100 is a good sample size for a quick price check; raise it for a full category export, or set 0 for no limit (still bounded by 'Max pages per category').

## `maxPagesPerCategory` (type: `integer`):

How deep to paginate inside each category (48 products per page). Raise it for large catalogues; lower it for a fast sample run.

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

Apify Proxy keeps long, large runs stable. It is switched on by default — keep it on for catalogue-scale exports.

## Actor input object example

```json
{
  "category": "all",
  "store": "US",
  "maxItems": 100,
  "maxPagesPerCategory": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All ASOS products scraped in this run (name, brand, prices, discount, colour, product and image URLs, flags).

# 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 = {
    "category": "all",
    "store": "US",
    "maxItems": 100,
    "maxPagesPerCategory": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/asos-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 = {
    "category": "all",
    "store": "US",
    "maxItems": 100,
    "maxPagesPerCategory": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/asos-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "category": "all",
  "store": "US",
  "maxItems": 100,
  "maxPagesPerCategory": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/asos-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/asos-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/KplQLsyZlJePHzrVP/builds/ABsVuCED8zaLadAhq/openapi.json