# AJIO Scraper: Fashion Search, Prices, Reviews (`automation_craft/ajio-scraper`) Actor

Scrape AJIO searches with AJIO's own filters, search links or product links, no login. Get price, MRP, offer price, discount, rating, colour group, category and seller id, plus written reviews and price monitors. Sizes with stock per size are a best effort add-on AJIO can refuse for hours.

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

## Pricing

from $1.14 / 1,000 products

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

### AJIO Scraper: Fashion Search, Prices, Reviews

**AJIO scraper** for Reliance's fashion store ajio.com: get the products of AJIO searches, narrowed with AJIO's own filters
(category, brand, gender, colour, size, price, discount, rating, on sale and every other filter of AJIO's panel), as clean rows
with price, MRP, offer price, discount, rating, colour group, category codes, badges, wishlist count and seller id, plus the
written reviews, the image gallery and monitors that keep only new products, report price and stock changes or keep a price
history. Product links and codes are read too, and on request each product's record with every size and its own stock status,
stock count and price (best effort, see below). No login, no cookies, no API key. You pay per product delivered; misses, repeats
and filtered products are free.

Use it to watch your brand's and other brands' prices and discounts on AJIO, to collect the products of fashion searches, to study
reviews, to run a price and stock watch that reports what changed since the last run, or
to keep a price history of every product with its lowest and highest price and a chart of each one.

**Good to know:** search results and their reviews came from AJIO at every hour we tested. AJIO's product records (product links
and codes, sizes and stock) sit behind a bot manager that lets proxy addresses in and out over the day, and at some hours it
refuses every address a run can use: product details are a best effort extra. Such a run names what it could not read in free
rows, charges only the start fee and the rows it delivered, and can be run again later. This Actor does not read whole category,
brand or curated list pages: AJIO refuses them for hours, and a search with the Category filter is not a whole category.

### Quick start

1. Open the Actor's **Input** tab.
2. Type **Search words** (linen shirt, kurta set, running shoes), or paste **AJIO links** of search pages or product pages.
   Product codes (443107169_purple) work too.
3. Optionally set AJIO's own filters: category (Men - Jeans), brands (NETPLAY, DNMX), price range, minimum discount, minimum
   rating, gender, colours, sizes, highlights, and any other filter of AJIO's panel such as "Occasion: Casual".
4. Set **Max products per search** (the form starts at 10; 100 when the field is left out) and turn on **Reviews** or, best effort, **Product details (sizes and stock)** if you want them.
5. Click **Start**. Download the results as JSON, CSV or Excel, or read them through the Apify API.

### What you get

#### Product rows (the Product event)

One row per AJIO product in one colour (AJIO lists each colour as its own product card). Example values are from a real run on
2026-10-16. The fill column is measured on 1,582 distinct search rows of the platform runs of 2026-10-21 ("record" where a field
is filled only by the product record).

| Field | Example | Fill | Notes |
|---|---|---|---|
| `optionCode` | `443398554_black` | 100% | the code after `/p/` in the product link: product number and colour |
| `productId`, `sizeCode` | `443398554`, `443398554014` | 100% | the product number and one size code of it |
| `name`, `brand`, `brandCode` | Shein Men Vintage Fly ... Jeans, Shein, `shein` | 100% | |
| `url` | https://www.ajio.com/shein-...-jeans/p/443398554_black | 100% | luxe products link to luxe.ajio.com |
| `price`, `mrp`, `discount`, `discountPercent`, `currency` | 799, 999, 200, 20, INR | 100% | price is the selling price; `discountPercent` is AJIO's discount text as a number, empty when there is no discount or when AJIO serves the row without the text (94% filled; `price` and `mrp` give the discount then, and the discount filter uses them) |
| `onSale` | true | 100% | the price is below the MRP |
| `offerPrice` | 559 | 100% | the price with AJIO's best coupon, where the listing shows one |
| `couponStatus` | Coupon Applicable | 100% | |
| `rating`, `ratingCount`, `ratingCountText`, `ratingCountExact` | 3, 23, "23", true | 75% | empty on products nobody rated yet; AJIO rounds big counts on listings ("1.8K"); a product record gives the exact count |
| `colorGroup`, `color` | black, Black | 100%, record | `colorGroup` is the colour word of AJIO's colour group of the option (the part after `_` of the option code, a word); `color` is AJIO's colour name, which its product record carries (details on, product links and codes) |
| `category` | Men > Western Wear > Jeans with codes 8302, 830216, 830216001 | 100% | segment, vertical and brick, each with code and name |
| `catalog`, `isLuxe`, `planningCategory` | rilfnlProductCatalog, false, Clothing | 100% (`planningCategory` 99%) | |
| `badges`, `isBestseller`, `isNew`, `isSellingFast`, `vibes` | SELLINGFAST | 8% | AJIO's selling points and "vibe" words (more often on the products of a brand word search AJIO answers with its brand page) |
| `wishlistCount`, `wishlistText` | 22000, "22K shoppers wishlisted in last 30 days" | 7% | |
| `sellerId`, `sellerSku` | ba964665-58e9-... | 60% | on more than half of search rows; the brand and curated pages AJIO answers some searches with do not carry it |
| `image`, `images`, `outfitImage` | image links | 100% | the gallery and the outfit picture (Image gallery off: the main image only) |
| `position`, `page`, `totalResults` | 1, 1, 36739 | 100% | where the product stood in AJIO's results |
| `returnWindowDays` | 10 | 100% | the return window AJIO lists for the product |
| `inStock`, `stockStatus`, `maxQuantity` | true, inStock, 10 | record | from the product record (Product details on, product links and codes) |
| `source` | { kind: search, input: searchTerms 1, searchWords: linen shirt } | 100% | which input found the row |

#### Product details (the Product detail event, optional)

With **Product details** on, each product row carries a `details` object read from AJIO's product record:

| Field | Example | Notes |
|---|---|---|
| `sizes[]` | size 30: inStock, `stockQuantity` 46, price 799, MRP 999 | every size with its own stock status (inStock, lowStock, outOfStock), stock count and price |
| `sizeCount`, `sizesInStock` | 6, 4 | |
| `colors[]` | BLACK, INDIGO BLUE with their option codes, prices and stock status | the other colours of the product |
| `ratingHistogram`, `ratingPercentages` | { 1: 7, 2: 4, 3: 1, 4: 5, 5: 6 } | the star breakdown |
| `fitRatings`, `qualityRatings` | Perfect 40%, Loose 40% ... | AJIO's fit and quality ratings |
| `attributes`, `fabric`, `washCare`, `fit`, `pattern` | 100% Cotton, Machine wash warm | every attribute AJIO lists |
| `manufacturer`, `marketedBy`, `importer`, `packer`, `countryOfOrigin`, `netQuantity`, `commodity`, `customerCare` | INDIA, 1 N, Men's Jeans | AJIO's mandatory information |
| `hsnCode` | 61032200 | |
| `returnable`, `returnWindowDays`, `returnPolicy`, `cashOnDelivery` | true, 10 | |
| `coupons[]`, `bankOffers[]` | NEW30: Flat 30% off upto 500 (new users) | codes, texts, the price with each coupon (`priceWithCoupon`), offer amounts with their unit (`amountType`: percent or rupees), end dates in UTC |
| `customerOpinionCount`, `writtenReviewCount`, `deliveryText`, `season`, `styleType`, `images` | | |

Two facts about sizes. AJIO answers some sold out sizes with "Stock info not available" and a count of 0: the row says
`outOfStock` with `stockQuantity: null` and `stockCountAvailable: false`, because the count is unknown, not zero (AJIO's own product
page lists those sizes as out of stock: 47 of 47 sizes checked). A `lowStock` size has 1 or 2 left and can be bought; AJIO's page
shows it to search engines as unavailable.

**AJIO protects these pages with a bot manager.** Search results were readable in every test run, and so were the reviews of the
products a search found. Product links and codes, product details, the reviews of product codes, and the brand, category or
curated page AJIO answers some search words with (netplay goes to the NETPLAY page) go through the proxy doors AJIO lets in at the time, and which doors those
are changes over the day: in the test runs of 2026-10-16 they were read in most runs. On 2026-10-21 they passed at 02:15 UTC, and
between 08:30 and 15:35 UTC more than half of our page and product code test runs got nothing (India's evening
included), and from 16:20 UTC the pages passed again while most product code runs were still refused; at 10:43, 12:30 and
14:02 UTC AJIO refused every proxy address we tried. A record that could not be read is free: the
product row is still delivered (and charged as a Product) without `details`, and its `detailsStatus` says why (`door_refused`,
`not_read`, `not_found`). A page that could not be read gives a free `source_unavailable` row.

#### Review rows (the Review event, optional)

With **Reviews** on, each product's written reviews come as rows of their own, right before the product's own row: `reviewId`, `optionCode`,
`productUrl`, `productName`, `rating`, `text`, `reviewerName`, `isVerifiedBuyer`, `helpfulCount`, `images`, `reviewedAt`. Order:
newest or most helpful; optional star filter and photos only. Written reviews are fewer than ratings on AJIO (a T-shirt with 1.8K
ratings had 70 written reviews). One run delivers at most 100,000 reviews: the products after that come without reviews and
say so in `reviewsStatus` (`left_out_run_limit`, or `partial_run_limit` for the product the bound cut short), with a free note row.

#### Product check rows (the Product check event, monitor in changes mode)

With a **Monitor name** and **Monitor mode** "changes", every product link or code is read on each run and delivered as one row
with its current `price`, `mrp`, `stockStatus`, the previous values, `changeType` (baseline, unchanged or changed) and `changes`
(which fields moved; a change of any size's price, stock status or stock count shows as `sizes`). With **Product details** on,
the row also carries every size in `details`.

#### Price history (the Price history event, monitor in history mode)

With a **Monitor name** and **Monitor mode** "history", every product your searches, search links and product codes find is
delivered on every run (charged as a Product, like any run) with its price history under that name: `trackedSince`,
`priceHistory` (every price, MRP and stock change the monitor recorded, with its date, the newest 50), `previousPrice`,
`previousMrp`, `priceChange`, `priceChangePercent`, `lowestPrice` and `lowestPriceAt`, `highestPrice` and `highestPriceAt`,
`isLowestPrice` and `historyChangeType` (baseline on the first run, then changed or unchanged). Each such row is one Price history
event. The run also stores one HTML **price report** with a chart of every product's price over time (the `PRICE-REPORT` record of
the run's key-value store; its address is in the summary row). A history the charge limit cannot pay is left off its row
(`historyStatus` says so) and is not recorded, so the next run still sees that price as new.

#### Free rows

- `coverage`: one per search or page: what was read, delivered and skipped, AJIO's total, the filters sent, and why it stopped
  (`end_of_results`, `max_items_per_search`, `source_page_cap`, ...). `complete` says whether it was read to the end or to your cap.
- `status`: input problems, product codes AJIO does not have, filters AJIO does not list for a page (with the closest values it
  lists), doors AJIO refused, inputs not started.
- `summary`: the last row of every run, with counts, the doors used and what was charged.

### How much does it cost to scrape AJIO?

Pay per event. Prices per 1,000 events by Apify plan:

| Event | Free | Bronze | Silver | Gold |
|---|---|---|---|---|
| Product (one product row) | $1.60 | $1.46 | $1.32 | **$1.14** |
| Product detail (sizes, stock and the record, optional) | $2.40 | $2.20 | $2.00 | $1.70 |
| Review (optional) | $1.10 | $1.00 | $0.90 | $0.80 |
| Product check (monitor in changes mode) | $0.70 | $0.65 | $0.60 | $0.50 |
| Price history (monitor in history mode) | $0.40 | $0.36 | $0.32 | $0.28 |

Platinum and Diamond plans pay the Gold price. Each run also pays one Actor start of $0.01 (the default 256 MB run pays one; the
start event has no plan discount). The Store pricing card shows these same prices per 1,000 events: "$1.14 / 1,000" on the Product
row means one product costs a little over a tenth of a cent on the Gold plan.

Examples on the Free plan: 100 products of a search cost $0.01 + 100 x $0.0016 = $0.17; the same 100 with sizes and stock add
$0.24; 1,000 products on the Gold plan cost $1.15. Products AJIO does not have, filtered or repeated products, and records that
could not be read are not charged.

### Input

| Setting | What it does |
|---|---|
| `searchTerms` | words to search, one search each |
| `startUrls` | AJIO links: search pages (their filters and order are kept) or product pages; category, brand and curated list pages are not read |
| `productCodes` | AJIO product codes (443107169_purple, or a size code) |
| `brands` | brand filter on every search; with no search words, each brand's name is searched with the brand filter |
| `gender`, `categoryNames`, `colors`, `sizes`, `highlights`, `filters` | AJIO's own filter values (see below) |
| `minPrice`, `maxPrice`, `minDiscount`, `minRating` | price range in rupees, discount and rating steps |
| `onlyOnSale` | only products priced below their MRP (the others are free); like every filter, for searches and search links |
| `sort` | relevance, discount, price low to high, price high to low, newest, rating |
| `maxItemsPerSearch`, `maxItems`, `maxPagesPerSearch`, `startPage`, `pageSize` | caps and paging |
| `includeDetails`, `includeReviews`, `maxReviewsPerProduct`, `reviewsSort`, `reviewsRating`, `reviewsWithPhotosOnly`, `includeImages` | add-ons |
| `monitorName`, `monitorMode`, `resetMonitor` | the monitor (below) |
| `maxRequestRetries`, `requestTimeoutSecs`, `maxConcurrency`, `requestDelaySecs`, `proxyConfiguration` | how the run asks AJIO |

#### Filters: AJIO's own names

Filters apply to searches and search links; product links and product codes are read as given. The Category filter
(`categoryNames`, "Men - Jeans") narrows a search, it does not turn it into a whole category: AJIO's search finds the products its
words match. Filters are matched against the filter panel AJIO lists for each search (the value as written first, case aside when none is). A value the page does
not list is noted on its coverage row with the closest values it does list; when none of a filter's values is listed, that page
delivers nothing and is free. One AJIO page takes at most 30 filter values: settings that add up to more are refused before the
run reads anything; only the run's start fee is charged. Price, discount, rating and brand (yours and a pasted link's own) are checked again on every row before
it is charged; with `includeDetails` they are checked on the product record, and a value the record lacks fails the check. Generic
filters are written "<filter name>: <value>": "Occasion: Casual", "Fit: Slim Fit", "Pattern: Solid".

#### The monitor

A **Monitor name** keeps a memory between runs (one per name, per Actor). In mode `new_only` (default) a scheduled run delivers and
charges only products and reviews it has not delivered before. In mode `changes` the product links and codes you give are read on
every run and delivered as Product check rows saying what changed. In mode `history` every product found is delivered on every run
with its price history and a price report (above). Use one name per mode. **Reset the monitor** starts the memory again.

### Integrations

Run it from the Apify API, a schedule, a webhook, Make, Zapier or n8n (the Apify node or module), or from an AI agent through the
Apify MCP server, where the input above is the tool's input and the dataset rows are its answer.

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~ajio-scraper/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["linen shirt"], "maxItemsPerSearch": 20, "includeDetails": true}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation_craft/ajio-scraper').call({ searchTerms: ['jeans'], categoryNames: ['Men - Jeans'], maxItemsPerSearch: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("automation_craft/ajio-scraper").call(run_input={"productCodes": ["443107169_purple"], "includeDetails": True, "includeReviews": True})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### What this Actor does NOT do

- It does not log in, add to a cart or touch any account.
- It does not read whole category, brand or curated list pages, and their links are refused at input (AJIO refuses those pages
  for hours); a search with the Category or Brands filter is the way to narrow a search.
- It does not read product links and codes, or sizes and stock, at an hour when AJIO's bot manager refuses every door the run can
  use: the run delivers what it read before, free `source_unavailable` rows name what was
  not read, rows without their record say so in `detailsStatus`, and only the start fee and the delivered rows are charged.
- It does not sort by popularity: AJIO offers six orders (relevance, discount, price both ways, newest, rating) and no popularity
  order.
- It does not mark sponsored products: AJIO's search answers carry no sponsored marker.
- It does not give seller names: AJIO's product record carries none; the seller id and seller SKU of search rows are delivered.
- It does not correct a filter value or category label AJIO does not list; it names the closest values AJIO lists instead.
- It does not read a whole category through a search: AJIO's search finds the products its words match (for some categories close
  to the whole category, for others a part of it) and stops near 75,000 products a search; split a large search with filters.
- It does not check delivery to a pincode.
- It does not give a written product description: AJIO's product record carries none; the product's details as AJIO lists them
  (fabric, fit, pattern, care and the other attribute lines) come in `details.attributes`.
- It does not read Luxe search, category, brand or curated pages on luxe.ajio.com; Luxe product pages are read, and Luxe products
  also come in www.ajio.com searches.

### FAQ

#### Does AJIO have an API?

AJIO publishes no product API for the public; its seller API is for sellers. This Actor reads the same answers AJIO's website uses
and gives them to you as rows through the Apify API, with no login or key.

#### How do I track AJIO prices?

Run a search or a list of product links on a schedule with a **Monitor name**: in mode `new_only` you get the new
products, in mode `changes` every watched product comes back with its price, MRP and stock and what changed since the last run,
and in mode `history` every product of your searches or links comes back with its price history, its lowest and highest price
and a chart in the run's price report.

#### Why does AJIO show different prices for different sizes?

On AJIO each size has its own price; a discount often applies to some sizes only. With **Product details** on, every size comes with
its own price and stock in `details.sizes`.

#### How do I scrape AJIO reviews?

Turn on **Reviews**: each product's written reviews come as rows with rating, text, reviewer name, verified buyer flag, photos,
helpful count and date, newest or most helpful first, optionally only one star rating or only reviews with photos.

#### Why does this Actor run with limited permissions?

It needs no access beyond its own storages: it writes its results to its own dataset, its run state to its own key-value store, and
a monitor's memory to a named store it creates itself. Limited permissions keep your account safe.

### Changelog

See the Changelog tab. First release: 0.1 (October 2026).

### More data tools by Automation Craft

- [Myntra Scraper: Fashion Products, Prices, Sizes](https://apify.com/automation_craft/myntra-scraper)
- [Amazon Product Scraper - Search, Best Sellers](https://apify.com/automation_craft/amazon-data-scraper)
- [Zalando Ads Library Scraper - Sponsored Products](https://apify.com/automation_craft/zalando-ads-library-scraper)
- [Amazon Sponsored Products Scraper - Ads by Keyword](https://apify.com/automation_craft/amazon-sponsored-products-scraper)
- [ShopBack Scraper: Cashback, Gift Cards, Affiliates](https://apify.com/automation_craft/affiliate-network-detector)
- [Mercari US Scraper: Listings, Sold Prices](https://apify.com/automation_craft/mercari-us-scraper)
- [Instagram Ads Library Scraper - Creatives, Video](https://apify.com/automation_craft/instagram-ads-library-scraper)
- [Google Trends API & Scraper: Trending Searches](https://apify.com/automation_craft/google-trends-scraper)

# Changelog

This Actor's version history is a separate document: https://apify.com/automation_craft/ajio-scraper/changelog.md

# Actor input Schema

## `searchTerms` (type: `array`):

Words to search on AJIO, one search per entry (linen shirt, kurta set, running shoes). Narrow a search with the filters below, the Category filter included (jeans with Men - Jeans). AJIO answers some words with one of its own brand, category or curated pages (netplay goes to the NETPLAY page); that page is then read through a door AJIO's bot manager can refuse for hours, and the coverage row says so. Each search delivers up to Max products per search.

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

Links copied from ajio.com: a search page (https://www.ajio.com/search/?text=linen%20shirt), with the filters and order AJIO put in the link, or a product page (https://www.ajio.com/dnmx-women-typographic-print-relaxed-fit-crew-neck-t-shirt/p/443107169_purple, luxe.ajio.com product pages too). Category, brand and curated list pages are not read (AJIO refuses them for hours): use search words with the Category or Brands filter. Display and tracking parts such as gridColumns and utm_source are ignored. Through the API, give each link as a text (an object {"url": "..."} is read too).

## `productCodes` (type: `array`):

AJIO product codes: the code after /p/ in a product link (443107169_purple: the product number and its colour) or a size code (443107169001). One product record is read for each; a code AJIO does not have gets a free status row.

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

Brands as AJIO lists them in its brand filter (NETPLAY, DNMX, LOUIS PHILIPPE): a filter on your searches (several brands match any of them). With no search words, each brand's name is searched with the brand filter. Product links and codes are read as given. A brand AJIO does not list for a search is noted on its coverage row; when it lists none of them, that search delivers nothing and is free.

## `gender` (type: `array`):

Only these values of AJIO's Gender filter (Men, Women, Boys, Girls, Infants). Several values match any of them.

## `categoryNames` (type: `array`):

Only these values of AJIO's Category filter on a search, written as AJIO shows them (Men - Jeans, Women - Kurtas). A value the search does not list is noted on its coverage row. A filtered search is not a whole category page: AJIO's search finds the products its words match.

## `colors` (type: `array`):

Only these values of AJIO's Colors filter (Blue, Black, Beige).

## `sizes` (type: `array`):

Only these values of AJIO's Size & Fit filter (M, L, 32, UK 8).

## `highlights` (type: `array`):

Only these values of AJIO's Highlights filter (BESTSELLER, NEW, NEWSEASON, SELLINGFAST, BESTPRICE). AJIO lists some in two spellings (BESTSELLER and Bestseller): a value written exactly is taken alone; a value AJIO lists only in another case is matched case aside.

## `filters` (type: `array`):

Any other filter of AJIO's filter panel, one per entry as "<filter name>: <value>" (Occasion: Casual, Fit: Slim Fit, Pattern: Solid, Sleeve: Full Sleeves, Vibes: 100% Cotton). The same filter name twice matches either value. Names and values are matched against the page's own panel; a filter with no listed value makes that page deliver nothing, free.

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

Only products priced at or above this many rupees (AJIO's price bands that overlap the range are sent, and the price is checked on every row).

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

Only products priced at or below this many rupees (AJIO's price bands that overlap the range are sent, and the price is checked on every row).

## `minDiscount` (type: `string`):

Only products discounted by at least this percent, one of AJIO's own steps (AJIO's discount filter, and checked on every row).

## `minRating` (type: `string`):

Only products rated at least this many stars (AJIO's rating filter, and checked on every row).

## `onlyOnSale` (type: `boolean`):

Only products whose price is below their MRP, in searches and search links (product links and codes are read as given). Products not reduced are read but not delivered and not charged.

## `sort` (type: `string`):

AJIO's order for every search: relevance (AJIO's default), discount, price low to high, price high to low, newest (What's New) or rating. AJIO offers no popularity order.

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

The most products one search or search link delivers (1 to 20,000). Default 100 when the field is left out; the form fills in 10 for a quick first run.

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

The most products the whole run delivers (inputs are read in order). Leave empty for no total cap.

## `startPage` (type: `integer`):

Start each search at this page of AJIO's results (1 to 2,000); the pages before it are not read.

## `maxPagesPerSearch` (type: `integer`):

The most result pages one search reads (1 to 2,000). Leave empty to stop only at Max products per search.

## `pageSize` (type: `integer`):

Products asked per result page (1 to 99). Leave empty for the most a page gives; it also sets what one Start page step skips.

## `includeDetails` (type: `boolean`):

Best effort: add each product's record (the Product detail event): every size with its stock status, stock count and price, the other colours, the star breakdown, fit and quality ratings, fabric, care and other attributes, manufacturer, importer and country of origin, HSN code, return terms, coupons, bank offers and the delivery note. The row then shows the record's own price, stock and rating. AJIO's bot manager can refuse product records for hours: a record that could not be read is free and the row says why; a run of product links or codes at such an hour pays only the start fee and what it delivered.

## `includeReviews` (type: `boolean`):

Add each product's written reviews as rows of their own (the Review event): rating, text, reviewer name, verified buyer flag, photos, helpful count and date.

## `maxReviewsPerProduct` (type: `integer`):

The most reviews delivered per product (1 to 2,000). Default 20.

## `reviewsSort` (type: `string`):

AJIO's review orders: newest (default) or most helpful.

## `reviewsRating` (type: `string`):

all (default), or only reviews with this many stars.

## `reviewsWithPhotosOnly` (type: `boolean`):

Only reviews that carry the buyer's photos.

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

On (default): every row carries the product's image gallery (model photos and the outfit picture). Off: only the main image.

## `monitorName` (type: `string`):

A name for a memory this Actor keeps between runs (one per name, per Actor). With it, a scheduled run delivers and charges only products and reviews it has not delivered before (mode new_only), watches product links and codes for price and stock changes (mode changes), or delivers every product it finds on every run with its price history (mode history).

## `monitorMode` (type: `string`):

new_only (default): only products and reviews not delivered before under this name. changes: every product link or code is read each run and delivered as one Product check row with its price, MRP and stock status, the previous values and what changed since the last run (with Product details on, the row also carries every size's price, stock status and stock count). history: every product your searches, search links and product codes find is delivered on every run with its price history under this name: when it was first tracked, every price, MRP and stock change with its date, the previous price and the change, and the lowest and highest price with their dates (the Price history event), plus one HTML price report with a chart of each product's price (the PRICE-REPORT record of the run's key-value store).

## `resetMonitor` (type: `boolean`):

Forget what the monitor delivered before and start again from this run.

## `maxRequestRetries` (type: `integer`):

How often a call AJIO did not answer is asked again (1 to 5, default 3). A refused door is replaced at once and does not count.

## `requestTimeoutSecs` (type: `integer`):

How long one call to AJIO may take before it is asked again (5 to 60, default 20). A door whose calls run into it or answer slower than 10 seconds twice in a row is replaced.

## `maxConcurrency` (type: `integer`):

How many products are read at once (1 to 3, default 3).

## `requestDelaySecs` (type: `integer`):

The least time between two requests of one kind (searches and reviews, product records, the pages AJIO answers some searches with), 0 to 10. Default 0: the Actor's own pace (about two requests a second, up to Parallel requests at once). With a delay, requests of a kind go one at a time.

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

Default: searches and reviews from the run's own address (Apify datacenter sessions if AJIO refuses it); product records, and the pages AJIO answers some searches with, through Apify datacenter sessions outside the US, product records then through Apify residential sessions in India when AJIO refuses them. Turn the Apify proxy off to use the run's own address only, or give your own proxy links.

## Actor input object example

```json
{
  "searchTerms": [
    "linen shirt"
  ],
  "onlyOnSale": false,
  "maxItemsPerSearch": 10,
  "includeDetails": false,
  "includeReviews": false,
  "reviewsWithPhotosOnly": false,
  "includeImages": true,
  "resetMonitor": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (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 = {
    "searchTerms": [
        "linen shirt"
    ],
    "maxItemsPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/ajio-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 = {
    "searchTerms": ["linen shirt"],
    "maxItemsPerSearch": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/ajio-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 '{
  "searchTerms": [
    "linen shirt"
  ],
  "maxItemsPerSearch": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation_craft/ajio-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation_craft/ajio-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/TanCMUuLUZ897U7qQ/builds/Ic9wZN6ReW9MgXDHM/openapi.json