# Indiamart Search Scrapper (`automation-hub/indiamart-search-scrapper`) Actor

IndiaMart Search Scraper extracts up to maximum results product listings per keyword and city with high accuracy. Ideal for supplier discovery, market research, and lead generation across multiple locations in a single run.

- **URL**: https://apify.com/automation-hub/indiamart-search-scrapper.md
- **Developed by:** [DataForge](https://apify.com/automation-hub) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 73 total users, 5 monthly users, 95.2% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $6.49 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Multi-City Multi-Keyword Search Scraper

This scraper extracts **product listing data from IndiaMart.com**, India’s largest B2B marketplace.  
It is designed for **fast and reliable discovery of product listings and sellers**, supporting **multiple keywords and multiple cities in a single run**.

The scraper focuses on **search result listings only**, making it lightweight, efficient, and suitable for lead generation and market research.

---

### How It Works (High Level)

- Searches IndiaMart using provided keywords  
- Applies optional city filters  
- Extracts **visible product cards from search results**  
- Returns **clean, structured listing data**

> ⚙️ The scraper uses a modern browser-based crawler to ensure accurate extraction from dynamically loaded pages.

---

### Input Parameters

| Parameter | Type | Required | Default | Description |
|---------|------|----------|---------|-------------|
| search_strings | Array | Yes | – | List of keywords to search on IndiaMart |
| cities | Array | No | Nationwide | List of city names to filter results |
| proxy_config | Object | No | Apify Residential (IN) | Proxy configuration |

---

### Input Schema Example

```json
{
  "search_strings": [
    "raw mango",
    "industrial fans"
  ],
  "cities": [
    "hyderabad",
    "chennai"
  ],
  "proxy_config": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IN"
  }
}
````

#### Notes

- Each keyword is processed independently
- Each city is applied as a filter
- All **keyword × city combinations** are handled in a single run
- If `cities` is omitted or empty, the scraper performs a **nationwide search**

***

### Output Schema

The scraper outputs an **array of product listing objects**, where each object represents a single product card visible on IndiaMart search results.

***

### Output Fields

| Field                  | Type    | Description                                             |
| ---------------------- | ------- | ------------------------------------------------------- |
| `search_keyword`       | String  | Keyword used for the search                             |
| `city`                 | String  | City filter applied (or `Nationwide`)                   |
| `product_name`         | String  | Product title                                           |
| `price`                | String  | Product price or `"Not Available"`                      |
| `seller`               | String  | Seller / company name                                   |
| `seller_location`      | String  | Seller location                                         |
| `seller_address`       | String  | Seller address                                          |
| `seller_contact`       | String  | Seller mobile number (normalized, if available)         |
| `rating`               | String  | Seller rating (e.g. `4.4`)                              |
| `reviews_count`        | String  | Number of reviews                                       |
| `seller_experience`    | String  | Seller experience (e.g. `10 yrs`)                       |
| `is_verified_supplier` | Boolean | Whether seller is marked as verified                    |
| `is_sponsored`         | Boolean | Whether the listing is sponsored                        |
| `lead_action`          | String  | Primary CTA shown (e.g. `Get Latest Price`, `Call Now`) |
| `product_url`          | String  | Product detail page URL                                 |
| `company_url`          | String  | Seller company profile URL                              |

***

### Output Example

```json
{
  "search_keyword": "raw mango",
  "city": "hyderabad",
  "product_name": "Fresh Raw Mango Pickle Achar Chutney (Medium)",
  "price": "Not Available",
  "seller": "Clarions-Raw Inn",
  "seller_location": "Hyderabad",
  "seller_address": "Plot No.1021, Koduru Residency, Pragathi Nagar, Hyderabad - 500090, Telangana",
  "seller_contact": "8047691846",
  "rating": "4.4",
  "reviews_count": "22",
  "seller_experience": "10 yrs",
  "is_verified_supplier": true,
  "is_sponsored": false,
  "lead_action": "Get Latest Price",
  "product_url": "https://www.indiamart.com/proddetail/fresh-raw-mango-2857295519797.html",
  "company_url": "https://www.indiamart.com/clarionsrawinn-hyderabad/"
}
```

***

### Key Features

- Multi-keyword support
- Multi-city filtering
- Nationwide search fallback
- Extracts **20 product listings per keyword-city combination**
- Cleaned URLs (query parameters removed)
- Normalized contact numbers
- Optimized for speed and stability
- Residential India proxy support

***

### Performance Characteristics

- Optimized for **fast execution**
- Focuses only on **search listings**
- Avoids deep page navigation
- Suitable for **bulk keyword discovery**

***

### Limitations

- Results are limited to **visible search listings**
- IndiaMART restricts access to additional search results beyond a certain threshold; as a result, the scraper retrieves **up to ~20 listings per keyword** without requiring mobile verification
- Some listings may not display price or contact details
- Seller contact numbers may be masked depending on availability
- This scraper does not crawl individual product or company pages

***

### Recommended Use Cases

- Market research
- Supplier discovery
- Lead generation
- Keyword-based product analysis
- City-wise supplier comparison

***

### Support & Troubleshooting

If you encounter issues:

1. Check Apify Actor logs
2. Ensure keywords are valid IndiaMart product terms
3. Verify city names are supported by IndiaMart
4. Use Residential IN proxies for best stability

**Support Email:** aadyanthasolutions@gmail.com

# Actor input Schema

## `search_strings` (type: `array`):

List of keywords to search on IndiaMART.

## `cities` (type: `array`):

Add one or more cities to filter results by location. Leave empty for a nationwide search. Supported cities: Ahmedabad, Bengaluru, Chennai, Coimbatore, Delhi, Faridabad, Gandhinagar, Ghaziabad, Gurugram, Hyderabad, Indore, Jaipur, Kanpur, Kolkata, Lucknow, Ludhiana, Mumbai, Nagpur, Noida, Patna, Pune, Rajkot, Surat, Thane, Vadodara, Varanasi, Visakhapatnam.

## `max_records_per_combination` (type: `integer`):

Maximum number of unique supplier listings to scrape per keyword and city combination.

## `proxy_config` (type: `object`):

Select proxies to be used by the crawler. Residential proxies recommended for best results.

## Actor input object example

```json
{
  "search_strings": [
    "asian paints"
  ],
  "max_records_per_combination": 50,
  "proxy_config": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

High-level view of product listings

## `product_details` (type: `string`):

Product-specific listing information

## `company_details` (type: `string`):

Seller and company information

## `search_details` (type: `string`):

Search-related metadata such as verification and ads

# 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 = {
    "search_strings": [
        "asian paints"
    ],
    "proxy_config": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-hub/indiamart-search-scrapper").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 = {
    "search_strings": ["asian paints"],
    "proxy_config": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-hub/indiamart-search-scrapper").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 '{
  "search_strings": [
    "asian paints"
  ],
  "proxy_config": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call automation-hub/indiamart-search-scrapper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indiamart Search Scrapper",
        "description": "IndiaMart Search Scraper extracts up to maximum results product listings per keyword and city with high accuracy. Ideal for supplier discovery, market research, and lead generation across multiple locations in a single run.",
        "version": "0.0",
        "x-build-id": "X0YJEkCO3KbzdhBwC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-hub~indiamart-search-scrapper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-hub-indiamart-search-scrapper",
                "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/automation-hub~indiamart-search-scrapper/runs": {
            "post": {
                "operationId": "runs-sync-automation-hub-indiamart-search-scrapper",
                "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/automation-hub~indiamart-search-scrapper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-hub-indiamart-search-scrapper",
                "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": [
                    "search_strings"
                ],
                "properties": {
                    "search_strings": {
                        "title": "Search Strings",
                        "type": "array",
                        "description": "List of keywords to search on IndiaMART.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Add one or more cities to filter results by location. Leave empty for a nationwide search. Supported cities: Ahmedabad, Bengaluru, Chennai, Coimbatore, Delhi, Faridabad, Gandhinagar, Ghaziabad, Gurugram, Hyderabad, Indore, Jaipur, Kanpur, Kolkata, Lucknow, Ludhiana, Mumbai, Nagpur, Noida, Patna, Pune, Rajkot, Surat, Thane, Vadodara, Varanasi, Visakhapatnam.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_records_per_combination": {
                        "title": "Max Results Per Keyword + City",
                        "minimum": 5,
                        "maximum": 125,
                        "type": "integer",
                        "description": "Maximum number of unique supplier listings to scrape per keyword and city combination.",
                        "default": 50
                    },
                    "proxy_config": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to be used by the crawler. Residential proxies recommended for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
