# IndiaMART Scraper - Suppliers, Exporters, Prices & GST (`haketa/indiamart-scraper`) Actor

Search IndiaMART and extract products with prices, MOQ, specs, supplier GST/IEC numbers, export countries, ratings and company websites for B2B lead generation.

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

## Pricing

from $3.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## IndiaMART Scraper – Suppliers, Exporters, Prices, GST & B2B Leads

**Extract supplier and product data from [IndiaMART](https://www.indiamart.com/), India's largest B2B marketplace, in minutes.** This IndiaMART scraper turns any search keyword into a clean, structured database of verified suppliers — complete with **prices, minimum order quantities (MOQ), product specifications, GST numbers, Import-Export Codes (IEC), the countries each supplier exports to, ratings, phone/call numbers and company websites.**

Whether you are doing **B2B lead generation, export sourcing, price monitoring, market research, or CRM enrichment**, this Actor gives you ready-to-use data exported as **JSON, CSV, Excel, or via API** — no coding required.

> 💡 Built for sales teams, importers, exporters, market researchers, dropshippers, procurement managers and growth marketers who need reliable Indian supplier data at scale.

---

### 🔎 Why scrape IndiaMART?

IndiaMART connects over **10 million suppliers** with millions of buyers across thousands of product categories — building materials, industrial machinery, textiles, chemicals, agriculture, electronics, packaging, pharmaceuticals and much more. It is the single richest public source of Indian manufacturer and wholesaler data on the internet.

But IndiaMART has no public bulk export, its search caps results, and copying listings by hand is slow and error-prone. This scraper automates the whole process: you give it keywords, it returns hundreds of clean supplier records you can sort, filter, and import anywhere.

**Common reasons people scrape IndiaMART:**

- Build **targeted B2B lead lists** of manufacturers and wholesalers
- Find **Indian exporters** that already ship to a specific country
- **Compare prices and MOQ** across suppliers for the same product
- **Enrich a CRM** with company websites, GST numbers and locations
- Track **competitors, market trends and product availability**
- Source products for **import, retail, dropshipping or private label**

---

### ✨ What this IndiaMART scraper does

- ✅ Searches IndiaMART by **any keyword** (e.g. `plywood`, `industrial valves`, `cotton fabric`, `basmati rice`)
- ✅ Returns **hundreds of unique suppliers per keyword** thanks to automatic category expansion (de-duplicated)
- ✅ Captures **full product details** — title, price, currency, MOQ, unit, specifications, images, description, product documents
- ✅ Captures **full supplier profiles** — company name, website, call number, GST number, IEC number, ratings, member-since, incorporation date
- ✅ Includes **export intelligence** — which countries each supplier exports to, verified-exporter status and IEC license
- ✅ Powerful **filters** — only verified exporters, only GST-verified suppliers, exports-to a target country, minimum supplier rating
- ✅ Exports to **JSON, CSV, Excel, XML** and integrates with Google Sheets, Make, Zapier, Slack and your own apps
- ✅ **No anti-bot headaches** — fast, reliable, and affordable to run at scale

---

### 🎯 Use cases

#### 1. B2B lead generation
Build laser-targeted lists of Indian manufacturers and wholesalers for outreach. Every record includes the **company name, website, call number, city, state and GST number** — everything your sales team needs to qualify and contact a supplier. Filter by rating to focus only on established, well-reviewed businesses.

#### 2. Export & import sourcing
Find Indian suppliers that **already export to your country**. Turn on `onlyExporters` and set `exportCountry` to (for example) `United Arab Emirates`, and the scraper returns only suppliers holding an **IEC license** that ship to the UAE — along with the full list of countries they export to. Ideal for importers, trading companies and sourcing agents.

#### 3. Price monitoring & benchmarking
Pull prices and MOQ for the same product across dozens of suppliers to understand market rates, spot the cheapest sources, and benchmark your own pricing. Re-run the Actor on a schedule to track how prices move over time.

#### 4. Market & competitor research
Map out who sells what, where, and at what price in any product category. See which cities dominate a category, which suppliers are verified exporters, and how products are specified — invaluable for market-entry, competitive analysis and category planning.

#### 5. CRM & database enrichment
Already have a list of products or categories? Feed them in and enrich your CRM or internal database with fresh **company websites, GST numbers, locations, ratings and export data**. The supplier website field is a perfect starting point for further email/contact enrichment.

#### 6. Procurement & supplier discovery
Procurement teams use the scraper to quickly discover and shortlist new suppliers for a part or material, compare their credentials (GST-verified, exporter, years in business), and reach out — cutting sourcing time from days to minutes.

#### 7. Dropshipping & private label sourcing
Find manufacturers for products you want to sell, complete with MOQ, specifications and images, so you can evaluate suppliers before requesting samples.

---

### 🏭 Popular categories & industries you can scrape

IndiaMART covers virtually every B2B category. This scraper handles all of them — just type any product into `queries`. Popular examples:

- **Building & construction** — plywood, TMT bars, cement, tiles, PVC pipes, paints, doors
- **Industrial machinery** — CNC machines, compressors, pumps, industrial valves, packaging machines
- **Textiles & apparel** — cotton fabric, garments, yarn, uniforms, safety wear, footwear
- **Agriculture & food** — basmati rice, spices, pulses, tea, grains, fertilizers, seeds
- **Chemicals** — dyes, resins, industrial chemicals, solvents, lab reagents
- **Electronics & electrical** — LED lights, sensors, cables, batteries, solar panels
- **Packaging** — corrugated boxes, plastic bottles, pouches, labels, caps
- **Pharma & medical** — nutraceuticals, medical equipment, surgical supplies, diagnostics
- **Leather & handicrafts** — leather gloves, bags, home décor, furniture, gifts
- **Automotive & engineering** — auto parts, bearings, fasteners, tools, castings

…and thousands more product categories across India's 10M+ supplier base.

### ⚙️ How it works

1. **Enter one or more search keywords** — exactly what you'd type into IndiaMART's search box.
2. **Set how many results you want** per keyword and (optionally) apply filters.
3. **Run the Actor** — it collects, de-duplicates and structures the data, then makes it available for download or via API.

That's it. No proxies to configure (a sensible default is built in), no login, no captcha solving.

---

### 📈 Get hundreds of results from a single keyword

A single exact IndiaMART search term only surfaces a small number of results. To solve this, the scraper has **automatic category expansion** (the `autoExpand` option, on by default).

When enabled, it follows the **related product categories that IndiaMART itself suggests** for your keyword and keeps collecting until it reaches your target. For example, `plywood` automatically fans out into *Marine Plywood, Shuttering Plywood, Waterproof Plywood, Greenply Plywood, Centuryply Plywood, Okoume Plywood* and more — all **de-duplicated by product ID**, so you never get the same supplier twice.

➡️ The result: one keyword like `plywood` can return **250+ unique, verified suppliers** in a single run.

If you prefer narrow, exact-match results, simply turn `autoExpand` off.

---

### 🔧 Input parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `queries` | array | ✅ Yes | One or more search terms, exactly as typed into IndiaMART (e.g. `plywood`, `industrial valves`). Add a city to bias results, e.g. `plywood mumbai`. |
| `maxItemsPerQuery` | integer | No | Target number of **unique** products to collect per keyword. Default `50`. |
| `autoExpand` | boolean | No | Follow related categories to reach high volume from one keyword (de-duplicated). Default `true`. |
| `onlyExporters` | boolean | No | Keep only suppliers with an IEC license / verified-exporter status. Default `false`. |
| `onlyGstVerified` | boolean | No | Keep only suppliers whose GST registration is verified. Default `false`. |
| `exportCountry` | string | No | Keep only suppliers that export to this country (e.g. `United States Of America`, `Nepal`). |
| `minSupplierRating` | integer | No | Keep only suppliers with a rating ≥ this value (0–5). Default `0`. |
| `proxyConfiguration` | object | No | Apify Proxy settings. Defaults to a US IP (see note). |

> ⚠️ **Export data needs a non-India IP.** IndiaMART only returns export-intelligence fields (`iecNumber`, `exportCountries`) to visitors outside India. The proxy country defaults to **US** for this reason — keep it outside India. The API has no anti-bot protection, so inexpensive datacenter proxies work perfectly.

#### Example input — simple lead list

```json
{
    "queries": ["plywood"],
    "maxItemsPerQuery": 250
}
````

#### Example input — export sourcing (suppliers shipping to UAE)

```json
{
    "queries": ["basmati rice"],
    "maxItemsPerQuery": 100,
    "onlyExporters": true,
    "exportCountry": "United Arab Emirates"
}
```

#### Example input — multiple categories, verified only

```json
{
    "queries": ["industrial valves", "cotton fabric", "leather gloves"],
    "maxItemsPerQuery": 200,
    "onlyGstVerified": true,
    "minSupplierRating": 3
}
```

***

### 📤 Output

The Actor stores one row per product, each with full supplier context. Data can be downloaded as **JSON, CSV, Excel, XML** or pulled via the Apify API.

#### Sample output record

```json
{
    "productName": "Basmati Rice (All Varieties)",
    "productUrl": "https://www.indiamart.com/proddetail/basmati-rice-2851234567.html",
    "price": 92,
    "priceText": "₹ 92/Kg",
    "currency": "INR",
    "minOrderQuantity": 26000,
    "minOrderUnit": "Kg",
    "specifications": {
        "Variety": "1509",
        "Processing Type": "White Sella",
        "Packaging Type": "PP Bag"
    },
    "companyName": "Mithuna Foods",
    "companyProfileUrl": "https://www.indiamart.com/mithunafoods/",
    "supplierWebsite": "https://www.mithunafoods.in/",
    "callNumber": "7942681234",
    "gstNumber": "33ABAFM0642H1ZR",
    "iecNumber": "2514003351",
    "isVerifiedExporter": true,
    "isGstVerified": true,
    "exportCountries": ["United Kingdom", "United States Of America", "Sri Lanka", "United Arab Emirates", "Canada"],
    "supplierRating": 4,
    "ratingCount": 128,
    "memberSinceDisplay": "14 yrs",
    "dateOfIncorporation": "2010-06-15T00:00:00.000Z",
    "city": "Chennai",
    "state": "Tamil Nadu",
    "country": "India"
}
```

#### Output fields reference

**Product fields**

| Field | Description |
| --- | --- |
| `productName` | Product title |
| `productUrl` | Link to the product page on IndiaMART |
| `displayId` | IndiaMART product ID (used for de-duplication) |
| `price` | Numeric price (when listed) |
| `priceText` | Human-readable price, e.g. `₹ 92/Kg` |
| `currency` | Price currency (e.g. INR) |
| `minOrderQuantity` | Minimum order quantity |
| `minOrderUnit` | Unit for the MOQ (Kg, Piece, Sq ft…) |
| `specifications` | Structured product attributes (Grade, Size, Brand…) |
| `description` | Product description text |
| `categories` | Product category names |
| `image` | Main product image URL |
| `images` | All product image URLs |
| `productDocument` | Product brochure/document URL (when available) |

**Supplier identity & contact**

| Field | Description |
| --- | --- |
| `companyName` | Supplier company name |
| `companyProfileUrl` | Supplier's IndiaMART profile page |
| `supplierWebsite` | Supplier's own website (great for enrichment) |
| `supplierId` | Unique supplier ID |
| `callNumber` | IndiaMART click-to-call number |
| `gstNumber` | GST registration number |
| `iecNumber` | Import-Export Code (IEC) |

**Trust & verification signals**

| Field | Description |
| --- | --- |
| `isExporter` | Holds an IEC license |
| `isVerifiedExporter` | Verified exporter on IndiaMART |
| `isGstVerified` | GST registration verified |
| `isEmailVerified` | Email verified |
| `isMobileVerified` | Mobile number verified |
| `supplierRating` | Average rating (0–5) |
| `ratingCount` | Number of ratings |

**Export intelligence**

| Field | Description |
| --- | --- |
| `exportCountries` | Countries the supplier exports to |
| `exportCountriesIso` | ISO codes for those countries |
| `exporterSince` | Date the supplier began exporting |
| `exporterSinceDisplay` | e.g. `10+ yrs` |

**Company background & location**

| Field | Description |
| --- | --- |
| `memberSince` / `memberSinceDisplay` | How long on IndiaMART |
| `dateOfIncorporation` | Company incorporation date |
| `companyVideo` | Company video URL (when available) |
| `address`, `city`, `district`, `state`, `pincode`, `country` | Full location |
| `searchQuery` | The keyword this record came from |
| `scrapedAt` | Timestamp of extraction |

***

### ✅ Proven results (real runs)

| Use case | Input | Unique results | GST | IEC | Export countries | Website |
| --- | --- | --- | --- | --- | --- | --- |
| Export lead-gen | `leather safety gloves` + only exporters | 61 | 100% | 96% | 85% | 100% |
| High volume | `industrial valves` (auto-expand) | 109 | 100% | 88% | 88% | 100% |
| Country targeting | `basmati rice` → exports to UAE | 20 | 100% | 100% | 100% | 100% |
| Single keyword | `plywood`, target 250 | 250 | 100% | 95% | — | 100% |

Company name, GST, supplier website and call number come back on **virtually every record**. Export-country and IEC coverage is highest for export-oriented sectors (textiles, leather, agriculture) and when "only verified exporters" is enabled.

***

### 🧰 Filters explained

- **Only verified exporters (`onlyExporters`)** — narrows results to suppliers with an IEC license. Use this for international sourcing and export lead lists.
- **Only GST-verified (`onlyGstVerified`)** — keeps only suppliers whose GST registration has been verified, raising overall data trustworthiness.
- **Exports to country (`exportCountry`)** — keeps only suppliers shipping to a specific market. Match is case-insensitive (e.g. `usa`, `United States Of America`).
- **Minimum rating (`minSupplierRating`)** — focus on established, well-reviewed suppliers only.

Combine filters freely — for example, *verified exporters, rating ≥ 4, exporting to Germany* — to produce a tightly qualified lead list.

***

### 🔌 Integrations

Send your IndiaMART data anywhere with Apify's built-in integrations and webhooks:

- **Google Sheets** — push leads straight into a spreadsheet
- **Make (Integromat) & Zapier** — trigger workflows on every run
- **Slack / email** — get notified when new data is ready
- **CRMs & databases** — via API, webhooks or no-code connectors
- **Your own app** — pull results through the Apify API in JSON

***

### ▶️ How to use this IndiaMART scraper (step by step)

1. Click **Try for free** at the top of this page.
2. In the **Input** tab, add your search keywords under `queries`.
3. Set `maxItemsPerQuery` (e.g. `250`) and apply any filters you need.
4. Click **Start** and wait for the run to finish (usually under a minute for a few hundred results).
5. Open the **Output / Dataset** tab and download your data as **JSON, CSV or Excel**, or copy the API endpoint to pull it programmatically.

You can also **schedule** the Actor to run daily/weekly to keep your supplier data fresh.

***

### ❓ Frequently asked questions

**Does it include supplier phone numbers and emails?**
IndiaMART hides personal phone numbers and email addresses behind a buyer login, so those are not available. You do get the **IndiaMART call number** (click-to-call line), verification flags, the supplier's own **website** and **IndiaMART profile URL** — the best starting points for contact enrichment.

**Can I get the GST number?**
Yes. The `gstNumber` field is returned on virtually every record, along with a `isGstVerified` flag.

**What is the IEC number?**
The Import-Export Code is a license required to export from / import into India. The `iecNumber` field tells you the supplier is set up for international trade — extremely useful for sourcing exporters.

**How many results can I get?**
With `autoExpand` on, a single keyword can return hundreds of unique suppliers. For even more, add multiple keywords or related terms. Exact counts depend on how many suppliers IndiaMART lists for your category.

**Why are export countries empty for some suppliers?**
Not every supplier is an exporter. Export fields are richest for export-oriented sectors and when `onlyExporters` is enabled. Also make sure your proxy country is **not India** (export data is only shown to non-India IPs).

**Can I filter by city or location?**
Yes — append a city to your keyword, e.g. `plywood mumbai`, to bias results toward that location.

**What export formats are supported?**
JSON, CSV, Excel (XLSX), XML, and RSS — plus direct API access.

**How much does it cost to run?**
You only pay for the results you collect (pay-per-result). The API has no anti-bot protection, so runs are fast and cheap even at scale.

**Can I run it on a schedule?**
Yes. Use Apify Schedules to run the scraper automatically (e.g. every morning) and keep your supplier database up to date.

**Is scraping IndiaMART legal?**
This Actor collects only publicly available data. You are responsible for using the data in compliance with IndiaMART's terms of use and applicable laws (including data-protection rules such as GDPR where relevant).

***

### 💡 Tips & best practices

- **Use specific keywords.** `marine plywood` returns more relevant suppliers than just `plywood`. Combine several related keywords for maximum coverage.
- **Turn on `onlyExporters`** when building export/import lead lists — it dramatically increases the quality of export-country and IEC data.
- **Set a realistic `maxItemsPerQuery`.** Larger targets take a little longer; 100–300 per keyword is a sweet spot for most users.
- **Keep the proxy outside India** to capture export intelligence fields.
- **Schedule regular runs** to monitor prices and discover newly listed suppliers over time.
- **De-duplication is automatic** — feel free to add overlapping keywords; you won't get duplicate suppliers.

***

### ⚠️ Limitations

- Personal emails and direct mobile numbers are gated behind IndiaMART login and are **not** included.
- Export-country and IEC data is only available for suppliers that have declared export activity, and only when scraping from a **non-India IP**.
- Result volume per keyword depends on how many suppliers IndiaMART lists in the related categories.

***

### 🚀 Get started

Click **Try for free**, enter a keyword like `plywood` or `industrial valves`, and get a clean list of verified Indian suppliers — with prices, GST, export data and websites — in under a minute. Perfect for **B2B lead generation, export sourcing, price monitoring and market research**.

Have a feature request or question? Open an issue from the Actor's page and we'll help.

# Actor input Schema

## `queries` (type: `array`):

One or more product / category search terms, exactly as you would type them into the IndiaMART search box (e.g. "plywood", "industrial valves", "cotton t-shirts"). Tip: append a city to narrow results, e.g. "plywood mumbai".

## `maxItemsPerQuery` (type: `integer`):

Maximum number of products to collect for each search query (after filters are applied). IndiaMART returns roughly 10 products per page, which are paginated automatically.

## `autoExpand` (type: `boolean`):

When enabled, the scraper automatically follows IndiaMART's related product categories for each query to collect far more unique suppliers (the search API only returns ~20 per exact term). Keep ON to reach high item counts from a single keyword. Results are de-duplicated.

## `onlyExporters` (type: `boolean`):

Keep only suppliers that hold an Import-Export Code (IEC) / are flagged as verified exporters. Ideal for international sourcing and export lead lists.

## `onlyGstVerified` (type: `boolean`):

Keep only suppliers whose GST registration has been verified by IndiaMART.

## `exportCountry` (type: `string`):

Keep only suppliers that export to this country (matched against the supplier's export-country list, case-insensitive, e.g. "United Arab Emirates", "Nepal", "USA"). Leave empty to disable.

## `minSupplierRating` (type: `integer`):

Keep only suppliers with a rating greater than or equal to this value (0-5). Set to 0 to disable.

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

IMPORTANT: export intelligence fields (IEC number, export countries) are only returned to NON-INDIA IPs. Keep the proxy country set to a non-India location (default: US). The API has no anti-bot, so cheap datacenter proxies work fine.

## Actor input object example

```json
{
  "queries": [
    "plywood",
    "industrial valves"
  ],
  "maxItemsPerQuery": 20,
  "autoExpand": true,
  "onlyExporters": false,
  "onlyGstVerified": false,
  "exportCountry": "United Arab Emirates",
  "minSupplierRating": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Clean JSON array of every scraped product with its supplier details.

## `productsCsv` (type: `string`):

The same data as a spreadsheet-ready CSV file.

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

Default dataset of this run for programmatic access.

# 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 = {
    "queries": [
        "plywood"
    ],
    "maxItemsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/indiamart-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 = {
    "queries": ["plywood"],
    "maxItemsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "plywood"
  ],
  "maxItemsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call haketa/indiamart-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IndiaMART Scraper - Suppliers, Exporters, Prices & GST",
        "description": "Search IndiaMART and extract products with prices, MOQ, specs, supplier GST/IEC numbers, export countries, ratings and company websites for B2B lead generation.",
        "version": "0.1",
        "x-build-id": "ITcdDX1C8UojB33XO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~indiamart-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-indiamart-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/haketa~indiamart-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-indiamart-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/haketa~indiamart-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-indiamart-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more product / category search terms, exactly as you would type them into the IndiaMART search box (e.g. \"plywood\", \"industrial valves\", \"cotton t-shirts\"). Tip: append a city to narrow results, e.g. \"plywood mumbai\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to collect for each search query (after filters are applied). IndiaMART returns roughly 10 products per page, which are paginated automatically.",
                        "default": 50
                    },
                    "autoExpand": {
                        "title": "Auto-expand to related categories",
                        "type": "boolean",
                        "description": "When enabled, the scraper automatically follows IndiaMART's related product categories for each query to collect far more unique suppliers (the search API only returns ~20 per exact term). Keep ON to reach high item counts from a single keyword. Results are de-duplicated.",
                        "default": true
                    },
                    "onlyExporters": {
                        "title": "Only verified exporters",
                        "type": "boolean",
                        "description": "Keep only suppliers that hold an Import-Export Code (IEC) / are flagged as verified exporters. Ideal for international sourcing and export lead lists.",
                        "default": false
                    },
                    "onlyGstVerified": {
                        "title": "Only GST-verified suppliers",
                        "type": "boolean",
                        "description": "Keep only suppliers whose GST registration has been verified by IndiaMART.",
                        "default": false
                    },
                    "exportCountry": {
                        "title": "Exports to country",
                        "type": "string",
                        "description": "Keep only suppliers that export to this country (matched against the supplier's export-country list, case-insensitive, e.g. \"United Arab Emirates\", \"Nepal\", \"USA\"). Leave empty to disable."
                    },
                    "minSupplierRating": {
                        "title": "Minimum supplier rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep only suppliers with a rating greater than or equal to this value (0-5). Set to 0 to disable.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "IMPORTANT: export intelligence fields (IEC number, export countries) are only returned to NON-INDIA IPs. Keep the proxy country set to a non-India location (default: US). The API has no anti-bot, so cheap datacenter proxies work fine.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```