# Meesho Scraper: Products, Prices, Reviews (`automation_craft/meesho-scraper`) Actor

Pull Meesho products from search words or search links, no login needed. Each row: price, special offer price, struck price, discount, star rating, fabric, category, listing date, Mall, Assured and ad flags; optional buyer reviews with the star breakdown. JSON, CSV, Excel or API, pay per product.

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

## Pricing

from $0.90 / 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

### Meesho Scraper: Products, Prices, Reviews

**Meesho scraper** for meesho.com, India's value marketplace: get the products of Meesho search words and search links as clean
rows with price, special offer price, struck price and discount, rating and rating count, category, fabric and size text, listing
date, shipping and the Mall, Assured and ad flags, plus on request each product's written reviews and its 1 to 5 star breakdown.
No login, no cookies, no API key. You pay per product delivered; words Meesho has no products for, filtered and repeated products
are free.

Use it to watch prices and discounts for the words your buyers search, to find new listings (Meesho's newest order), to compare
value fashion and home goods across searches, or to study what buyers write in reviews.

### Quick start

1. Open the Actor's **Input** tab.
2. Type **Search words** (kurti, saree, phone cover, bedsheet), or paste **Meesho search links** (https://www.meesho.com/search?q=kurti).
3. Optionally set filters: price range in rupees, minimum rating, minimum discount, Meesho Mall only, Meesho Assured only, leave out
   ads.
4. Set **Max products per search** (default 100), and turn on **Reviews** if you want them, or **Deep search** for more than about
   1,450 products of a word in relevance order.
5. Click **Start**. The prefill (10 products of "kurti") finished in 4 to 9 seconds in our platform runs of 2026-10-25; a search
   of 300 products took 9 to 45 seconds, depending on how fast Meesho answered. 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 Meesho product (`type: "product"`), in the order Meesho ranks them. Fill rates measured on 3,499 product rows of 22
platform runs on 2026-10-25 (kurti, saree, bedsheet, phone cover and others).

| Field | Example | Fill | Notes |
|---|---|---|---|
| `productId`, `productNumber`, `catalogId` | `8mpzxj`, `521893927`, `175740214` | 100% | Meesho's product id (as in its links), its number and the catalog (a supplier's group of designs) |
| `name`, `catalogName`, `url` | `KVS TOP BLACK`, `https://www.meesho.com/kvs-top-black/p/8mpzxj` | 100% | |
| `price`, `currency` | `183`, `INR` | 100% | the price Meesho shows, in rupees |
| `originalPrice`, `discountPercent`, `discountAmount` | `196`, `6`, `13` | 76% | the struck price and the discount, when Meesho shows one; the percent is worked out from the two prices and rounded down (Meesho's own figure is rounded to the nearest percent, so 9.55 percent shows as 10) |
| `specialOfferPrice`, `specialOfferDiscount`, `specialOffers`, `specialOfferList` | `159`, `24`, `₹159 with 1 Special Offer` | 100% | the price after Meesho's special offers and what they are |
| `dealPrice`, `dealEndsAt` | `161`, `2026-10-25T11:29:59.000Z` | 8% | a timed deal |
| `rating`, `ratingCount` | `3.9`, `38759` | 22% | most new listings carry no rating yet |
| `category`, `categoryId` | `Kurtis & Kurtas`, `1001` | 100% | |
| `brand` | `Mohini Dyeing` | 25% | when the supplier gives one |
| `fabric`, `sizesText`, `attributes`, `description` | `Rayon`, `["S, XL, XS, L, XXL, M"]` | 13%, 5%, 56%, 100% | from the product's own text; `description` is Meesho's short product text |
| `designs` | `2` | 100% | how many designs the catalog has |
| `freeDelivery`, `shippingCharges`, `expressDelivery` | `false`, `0`, `false` | 100% | |
| `isMall`, `isAssured`, `isAd` | `false`, `false`, `false` | 100% | Meesho Mall, Meesho Assured, a sponsored place |
| `tags`, `flags` | `["NEXT DAY DISPATCH"]`, `{ "lowestPrice": true, "sale": true }` | 52%, 100% | Meesho's badges |
| `listedAt`, `activatedAt` | `2025-04-05T00:17:29+0530` | 100% | when the listing was made and went live |
| `supplierStateCode`, `gstType` | `RJ`, `GSTIN` | 100% | the supplier's state |
| `shareText`, `consumerShareText` | | 100% | the texts Meesho offers for sharing the product |
| `image`, `images` | catalog and product image links | 100% | `includeImages` off keeps `image` (the main image) and leaves `images` empty |
| `position`, `page`, `source` | `3`, `1`, `{ "kind": "search", "searchWords": "kurti", "shard": "relevance" }` | 100% | where the row was found |
| `matchesSearchWords` | `true` | 100% | the row's own text carries every word of the search |
| `scrapedAt` | `2026-10-25T09:44:12.672Z` | 100% | |

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

With **Reviews** on, each product's written reviews come as rows of their own (`type: "review"`), up to **Max reviews per product**
(default 20): `reviewId`, `productId`, `productUrl`, `productName`, `rating`, `text`, `reviewer` (the name Meesho shows with the
review), `createdAt`, `helpfulCount`, `media` (photo links). The product row then also carries `reviewCount` (Meesho's count of
written reviews), `ratingBreakdown` (how many ratings at 1, 2, 3, 4 and 5 stars, for example `{ "1": 1386, "2": 627, "3": 997,
"4": 1391, "5": 5578 }`) and `reviewsStatus` (`read`, `partial`, `failed`, `not_read_unpaid_work`, `not_read_charge_limit`, `not_read_run_cap`, `stopped`), with `reviewsDelivered`
(how many of its reviews came as rows) and, when the charge limit left some out, `reviewsLeftOutByChargeLimit: true`. A run reads at most 200,000 reviews in all (split a larger review export into several runs). Under a charge limit the
products come first: reviews are read only with what the limit leaves after the products the search still asks for.

#### Free rows

- `coverage`: one per search: what was read and delivered, the products filtered out or already delivered, Meesho's own spelling of
  the words when it corrected them (`correctedSearchWords`), the slices of a deep search (`shards`, `shardStops`) and why it stopped
  (`stoppedBy`: `end_of_results`, `max_items_per_search`, `meesho_depth_reached`, `no_matching_products`, ...). `complete` says
  whether it was read to the end or to your cap.
- `status`: `invalid`, `no_matching_products`, `lookup_failed`, `source_unavailable`, `skipped`, `note`, `stopped`.
- `summary`: the last row of every run, with counts and what was charged.

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

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

| Event | Free | Bronze | Silver | Gold |
|---|---|---|---|---|
| Product (one product row) | $1.33 | $1.22 | $0.99 | **$0.90** |
| Review (optional) | $0.95 | $0.70 | $0.48 | $0.45 |

Platinum and Diamond plans pay the Gold price. Each run also pays one Actor start of $0.007 (one per GB of run memory; 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:
"$0.90 / 1,000" on the Product row means one product costs less than a tenth of a cent on the Gold plan.

Examples: 1,000 products on the Gold plan cost 1,000 x $0.0009 + $0.007 = $0.907. 100 products with 20 reviews each cost $0.09 +
2,000 x $0.00045 + $0.007 = $0.997 on the Gold plan. Words Meesho has no products for, filtered and repeated products, pages that
could not be read and every free row are not charged.

### Input

| Setting | What it does |
|---|---|
| `searchTerms` | words to search, one search each |
| `startUrls` | meesho.com search links (`/search?q=<words>`; a link's newest order, `s=created_desc`, is kept when `sort` is left out) |
| `sort` | Meesho's own order: `relevance` (default) or `newest`; set, it applies to search links too |
| `sortResults` | the order the products of each search are delivered in, sorted among the products read for it: `price_low_to_high`, `price_high_to_low`, `rating`, `rating_count`, `discount` |
| `deepSearch` | past Meesho's relevance depth of about 1,450 products per word, also read the other order and Meesho's nine price bands |
| `minPrice`, `maxPrice`, `minRating`, `minDiscount`, `mallOnly`, `assuredOnly`, `excludeAds` | filters, checked on every row |
| `maxItemsPerSearch`, `maxPagesPerSearch`, `maxItems`, `pageSize` | caps and paging (`maxItemsPerSearch` 1 to 20,000, default 100; a run delivers at most 100,000 products and reads at most 200,000 reviews, whatever `maxItems` says) |
| `includeReviews`, `maxReviewsPerProduct`, `includeImages` | add-ons (`maxReviewsPerProduct` default 20, `includeImages` on by default) |
| `maxRequestRetries`, `requestTimeoutSecs`, `maxConcurrency`, `requestDelaySecs`, `proxyConfiguration` | how the run asks Meesho (defaults 3 tries per call in all, 25 seconds, 3 products' reviews at a time, no pause) |

A setting name the Actor does not have (a misspelt filter, for example) stops the run before anything is read, with a free status
row, so a typo never runs a wider search than you meant.

#### Depth and deep search

In relevance order Meesho stops adding new products after about 1,450 per search word. Its newest order went much deeper in our runs:
on 2026-10-25 it gave 18,531 products of "saree" listed in the last two days, every one carrying the word. With **Deep search** on, a
search read past the relevance depth then also reads the other order and Meesho's nine price bands (under 199 rupees, 200 to 249, 250
to 299, 300 to 399, 400 to 499, 500 to 599, 600 to 699, 700 to 799, 800 and above), and delivers each product once. On 2026-10-25 a
deep search of "saree" delivered 20,000 products (its cap) in about 19 minutes, 1,469 from relevance and the rest from newest, and one
of "phone cover" capped at 3,000 took 2.5 to 4.5 minutes. Each slice shows on the coverage row (`shardStops`, with how many products
each slice had added).

#### Words Meesho has no products for

Meesho answers a word it has no products for with a general feed of unrelated products and no flag. The first page of every search
(20 products) decides: when none of its products carries any of your words (or Meesho's own spelling of them) and Meesho ranks the
words as an unknown query, the search ends with a free `no_matching_products` row. Otherwise Meesho's products are delivered as
Meesho ranks them, and each row says in `matchesSearchWords` whether its own text carries every word of the search (Meesho also
shows related products, for example "Tanjore art" frames for "tanjore painting"), so you can keep only exact matches in your sheet.
A run stops when unpaid work (pages of words without products, filtered products) has used up its allowance: three or four words in
a row without products before the first product is delivered (platform runs of 2026-10-25), so put the words you are surest of first;
every product delivered adds to the allowance.

#### Filters

Meesho does not say which filters it applied to an answer, so this Actor checks every filter you set on every row before it is
charged: a row outside your price range, rating, discount, Mall, Assured or ads setting is left out and free. A minimum rating of
1, 2, 3, 3.5 or 4 stars lets through only rated products. Meesho's discounts are mostly small: on 2026-10-25, by Meesho's own discount figure, 17 to 122 of 250
search products per word carried 10 percent or more, but only 1 to 44 carried 20 percent or more, so a high minimum discount on a word
with few such products ends that search on its allowance of unpaid pages (the coverage row says so).

#### Proxy and Meesho's bot protection

Meesho answers only addresses in India, so the Actor uses Apify residential addresses in India whatever proxy group you name. You can
give your own proxy links instead; they must exit in India. If Meesho refuses a run's searches (on every address, or with its bot
challenge), every search not read gets a free `source_unavailable` row, nothing is charged for it, and the run's status message
names Meesho as the failing side.

### What this Actor does not do

- It does not read Meesho product pages, categories or shops: Meesho's bot protection refused those pages after about 120 product
  pages at a normal pace and kept refusing them for hours in our tests of October 2026, while its search and reviews stayed open.
  So there is no supplier name, sizes in stock, cash on delivery, delivery estimate or product page description, and product,
  category and shop links get a free status row. Search for the product's words instead, or use Meesho's own category words as
  search words.
- It does not take a catalog id or a product id as input.
- It does not give a product weight: Meesho's web pages carry none.
- It does not log in, and reads no supplier panel or affiliate data: it reads only what meesho.com shows any visitor.
- It does not get products from Meesho in price, rating or popularity order: Meesho applies only relevance and newest (it answers a
  popularity order with an error). `sortResults` orders the
  products the run read.
- It does not give stock counts or the delivery date for your pincode.
- It does not read Meesho's Android app.
- It does not read a link that carries Meesho filters (its `f` part): set the filters in the input instead.
- It keeps no memory between runs: every run delivers what it reads, and it has no "new products only", price change or alert mode.
  Schedule the same input and compare runs by `productId` in your own sheet or workflow.

### FAQ

#### Does Meesho have an API?

Meesho's APIs are for its suppliers and need a supplier login; there is no public product API. This Actor reads the search results
meesho.com shows any visitor, logged out and with no key, and returns them as rows you can fetch through the Apify API, on a schedule
or from Make, n8n, Zapier and AI agents.

#### How do I scrape Meesho reviews?

Turn on **Reviews**: each delivered product's written reviews come as rows with `rating`, `text`, `reviewer`, `createdAt`,
`helpfulCount` and photo links, up to **Max reviews per product** (default 20), and the product row carries the 1 to 5 star
breakdown.

#### How many products does a Meesho search give?

In relevance order about 1,450 per search word. Meesho's newest order goes deeper: 18,531 products of "saree" on 2026-10-25. Turn on
**Deep search** to read both orders and Meesho's nine price bands, up to 20,000 products per search, each delivered once.

#### How do I track Meesho prices?

Schedule the same searches: every run delivers each product's current `price`, `specialOfferPrice` and `discountPercent` under its
`productId`, so you can compare runs in your own sheet or workflow. With **Order** set to newest, a search starts with Meesho's newest
listings.

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

It needs no access beyond its own storages: it writes its results to its own dataset and its run state to its own key-value store.
Limited permissions keep your account safe.

### Use it through the API and integrations

Run it from the Apify API, a schedule, a webhook, Make, n8n or Zapier (the Apify module or node), 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~meesho-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["kurti"], "maxItemsPerSearch": 20}'
```

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

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation_craft/meesho-scraper").call(run_input={"searchTerms": ["bedsheet"], "includeReviews": True, "maxItemsPerSearch": 5})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### 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)
- [AJIO Scraper: Fashion Search, Prices, Reviews](https://apify.com/automation_craft/ajio-scraper)
- [Flipkart Scraper: Products, Prices, Sellers](https://apify.com/automation_craft/flipkart-scraper)
- [Nykaa Scraper: Beauty Products, Prices, Reviews](https://apify.com/automation_craft/nykaa-scraper)
- [IndiaMART Scraper: B2B Products, Prices, Suppliers](https://apify.com/automation_craft/indiamart-scraper)
- [AliExpress Search Scraper - Products and Prices](https://apify.com/automation_craft/aliexpress-search-scraper)
- [Amazon Product Scraper - Search, Best Sellers](https://apify.com/automation_craft/amazon-data-scraper)
- [Trendyol Scraper: Products, Prices, Reviews](https://apify.com/automation_craft/trendyol-scraper)

# Changelog

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

# Actor input Schema

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

Words to search on Meesho, one search per entry (kurti, saree, phone cover, bedsheet). Each search delivers up to Max products per search. Meesho answers words it has no products for with unrelated products; when its answer shows that (no row carries any of the words, and Meesho ranks them as an unknown query), this Actor delivers nothing for them, free.

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

Search links copied from meesho.com (https://www.meesho.com/search?q=kurti; the newest order is kept when the link carries s=created_desc). This Actor reads Meesho's search only: a product, category or shop link is not read and gets a free row saying so. Tracking parts such as \_ms and utm_source are ignored; a link carrying Meesho filters (its f part) is refused, set the filters below instead. Through the API, give each link as a text (an object {"url": "..."} is read too).

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

Meesho's own order of a search: relevance (Meesho's default) or newest (newest listings first). Meesho applies no other order; to get products in price or rating order, use Order of delivered products. Set here, it applies to search links too (a link's own order is kept only when this is left out).

## `sortResults` (type: `string`):

The order the products of each search are delivered in, sorted by this Actor among the products it read for that search (up to Max products per search): none (Meesho's order), price low to high, price high to low, rating, number of ratings, or discount.

## `deepSearch` (type: `boolean`):

In relevance order Meesho stops adding new products after about 1,450 per search word. With this on, a search then also reads the other order (newest, which went past 18,000 products of saree on 2026-10-25) and each of Meesho's nine price bands (Under 199 rupees to 800 and above), each product delivered once. Useful with a high Max products per search.

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

Only products priced at or above this many rupees. Checked by this Actor on every row; rows outside it are free.

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

Only products priced at or below this many rupees. Checked on every row; Meesho's own price band is sent along to narrow the search.

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

Only products rated at least this many stars (1, 2, 3, 3.5 or 4). Checked on every row; a product without a rating does not pass.

## `minDiscount` (type: `integer`):

Only products whose discount off the MRP is at least this many percent (1 to 99). Checked on every row.

## `mallOnly` (type: `boolean`):

Only products Meesho marks as Mall (branded products from authorised sellers).

## `assuredOnly` (type: `boolean`):

Only products Meesho marks as Assured.

## `excludeAds` (type: `boolean`):

Leave out the sponsored products Meesho mixes into search results (rows flagged isAd).

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

The most products one search delivers (1 to 20,000). Left out: 100.

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

The most Meesho pages one search reads (1 to 400). A search page holds up to 200 products (the first page of a search 20).

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

The most products the whole run delivers (1 to 100,000). Left out, a run still delivers at most 100,000 products (split a larger export into several runs).

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

How many products one search page asks Meesho for (20 to 200). Left out: the Actor picks the most a page holds for the search (up to 200). The first page of every search asks for 20, enough to tell whether Meesho has products for the words.

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

Deliver written reviews of each product (rating, text, reviewer name as Meesho shows it, date, helpful count, photos) as their own rows, charged as Review each. The product row then also carries Meesho's review count and its 1 to 5 star breakdown.

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

The most reviews delivered per product (1 to 1,000). Left out: 20. A run reads at most 200,000 reviews in all; the products after that come without reviews.

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

Deliver every image link of a product (on by default); off keeps only the main image.

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

How many times a call is tried in all before it is given up when Meesho does not answer it (1 to 5; 3 means the first try and two more). Left out: 3.

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

How long one call may take (10 to 60). Left out: 25.

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

Products whose reviews are read at the same time (1 to 3). Left out: 3.

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

The least time between two calls of one kind (0 to 10). Left out: 0, the Actor's own pace.

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

Meesho answers only addresses in India, so the Actor uses Apify residential addresses in India whatever the group named here. You can give your own proxy links instead (they must exit in India).

## Actor input object example

```json
{
  "searchTerms": [
    "kurti"
  ],
  "maxItemsPerSearch": 10,
  "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": [
        "kurti"
    ],
    "maxItemsPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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