# TradeIndia Scraper - B2B Suppliers, Prices, Email & Phone (`haketa/tradeindia-scraper`) Actor

Search TradeIndia.com and extract products with prices, MOQ, supplier email & phone, business type, certifications and verification for B2B lead generation.

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

## Pricing

from $2.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

## TradeIndia Scraper – B2B Suppliers, Prices, Email & Phone

**Extract supplier and product data from [TradeIndia.com](https://www.tradeindia.com/), one of India's largest B2B marketplaces, in minutes.** This TradeIndia scraper turns any keyword into a clean, structured database of suppliers — complete with **product names, prices, MOQ, business type, certifications, verification status, and — unlike most B2B scrapers — the supplier's email address and phone number.**

Export everything as **JSON, CSV, Excel, or via API** — perfect for **B2B lead generation, sourcing, price research and CRM enrichment.** No coding required.

> 💡 Built for sales teams, importers, sourcing agents, lead-gen agencies and market researchers who need ready-to-contact Indian supplier leads at scale.

---

### 🔎 Why scrape TradeIndia?

TradeIndia connects millions of buyers with hundreds of thousands of Indian manufacturers, exporters and wholesalers across every product category. Its listings are a goldmine for B2B prospecting — and crucially, TradeIndia exposes **direct contact details (email + phone)** on its product listings, which makes it one of the most actionable B2B data sources available.

But TradeIndia has no public bulk export. This scraper automates the whole process: you give it keywords, it returns hundreds of clean, contact-ready supplier records.

**Common reasons people scrape TradeIndia:**

- Build **ready-to-contact B2B lead lists** (with email + phone)
- Find **Indian manufacturers and exporters** for sourcing
- Compare **prices and MOQ** across suppliers
- Enrich a **CRM** with supplier firmographics and contacts
- Run **market and competitor research** on Indian B2B

---

### ✨ What this TradeIndia scraper does

- ✅ Searches TradeIndia by **any keyword** (e.g. `led light`, `industrial valves`, `cotton yarn`)
- ✅ Returns **hundreds of products per keyword** with automatic pagination (de-duplicated)
- ✅ Captures **product details** — name, price, MOQ, image, description, category, brand
- ✅ Captures **supplier contact** — **email, mobile, phone**, company name, profile URL
- ✅ Captures **business intelligence** — business type (manufacturer/exporter/trader/distributor), certifications, TrustStamp, years on platform, location
- ✅ Powerful **filters** — only manufacturers, only exporters, only TrustStamp-verified
- ✅ Exports to **JSON, CSV, Excel, XML** and integrates with Google Sheets, Make, Zapier, Slack and your apps

---

### 🎯 Use cases

#### 1. B2B lead generation (with contacts)
This is TradeIndia's killer feature: most listings include the supplier's **email and phone**. Build prospect lists your sales team can contact immediately — no manual contact-hunting.

#### 2. Sourcing & import
Find Indian manufacturers and exporters for any product. Filter to manufacturers/exporters, compare prices and MOQ, and reach out directly.

#### 3. Price & MOQ research
Pull prices and minimum order quantities across dozens of suppliers to benchmark market rates and negotiate better.

#### 4. CRM & data enrichment
Enrich your CRM with supplier email, phone, location, business type and certifications — ready-to-use firmographics.

#### 5. Market & competitor research
Map who sells what, where, at what price, with which certifications — across India's B2B landscape.

#### 6. Export-partner discovery
Filter to exporters to find Indian suppliers experienced in international trade.

---

### 🏭 Popular categories you can scrape

TradeIndia covers nearly every B2B category — just type any product into `queries`:

- **Lighting & electrical** — LED lights, panels, wires, switches
- **Industrial machinery** — pumps, valves, CNC, compressors
- **Textiles & yarn** — cotton, fabric, garments, threads
- **Chemicals** — dyes, solvents, industrial chemicals
- **Agriculture & food** — rice, spices, pulses, equipment
- **Building materials** — pipes, tiles, hardware, tools
- **Packaging** — boxes, films, bottles, pouches
- **Auto parts, medical, electronics, handicrafts** and thousands more

---

### ⚙️ How it works

1. **Enter one or more keywords** — exactly as typed into TradeIndia search.
2. **Set how many results you want** per keyword and apply optional filters.
3. **Run the Actor** — it collects, de-duplicates and structures the data for download or API.

No login, no captcha solving.

---

### 🔧 Input parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `queries` | array | ✅ Yes | Search keywords (e.g. `led light`, `industrial valves`). |
| `maxItemsPerQuery` | integer | No | Max products per keyword. ~28/page, paginated. Default `60`. |
| `onlyManufacturers` | boolean | No | Keep only manufacturer suppliers. |
| `onlyExporters` | boolean | No | Keep only exporter suppliers. |
| `onlyTrustStamp` | boolean | No | Keep only TrustStamp-verified suppliers. |
| `proxyConfiguration` | object | No | Apify Proxy settings. Datacenter works fine. |

#### Example input — lead list

```json
{
    "queries": ["led light"],
    "maxItemsPerQuery": 200
}
````

#### Example input — verified exporters only

```json
{
    "queries": ["cotton yarn", "leather gloves"],
    "maxItemsPerQuery": 150,
    "onlyExporters": true,
    "onlyTrustStamp": true
}
```

***

### 📤 Output

One row per product with full supplier context. Download as **JSON, CSV, Excel, XML** or via API.

#### Sample output record

```json
{
    "productName": "Solar LED Street Light",
    "productUrl": "https://www.tradeindia.com/products/solar-led-street-light-c6823179.html",
    "price": "2000.00 INR (Approx.)",
    "priceValue": 2000,
    "currency": "INR",
    "minOrderQuantity": "10",
    "category": "Solar Products & Equipment",
    "companyName": "ZARAL ELECTRICALS",
    "email": "sales@zaralelectricals.com",
    "mobile": "+918045475647",
    "businessTypes": ["Manufacturer", "Exporter"],
    "isManufacturer": true,
    "isExporter": true,
    "hasTrustStamp": true,
    "memberSinceYears": 11,
    "city": "Vadodara",
    "country": "India",
    "searchKeyword": "led light",
    "scrapedAt": "2026-05-25T20:00:00.000Z"
}
```

#### Output fields reference

**Product**

| Field | Description |
| --- | --- |
| `productName` | Product title |
| `productUrl` | Link to the product page |
| `productId` | TradeIndia product ID (de-duplication) |
| `price` / `priceValue` | Price text and numeric value |
| `currency` / `unit` | Currency and unit |
| `minOrderQuantity` | Minimum order quantity |
| `productImage` | Product image URL |
| `description` | Product description |
| `category` | Product category |
| `brandName` | Brand |

**Supplier & contact**

| Field | Description |
| --- | --- |
| `companyName` | Supplier company name |
| `companyProfileUrl` | Supplier profile page |
| `email` | Supplier email address |
| `mobile` | Supplier mobile number |
| `phone` | Supplier phone number |
| `businessTypes` | Manufacturer / Exporter / Trader / Distributor / Supplier |
| `isManufacturer` / `isExporter` / `isTrader` | Business-type flags |
| `hasTrustStamp` / `isVerified` | Verification flags |
| `certifications` | Standards/certifications (e.g. ISO 9001) |
| `memberSinceYears` | Years on TradeIndia |
| `established` | Year established |

**Location & meta**

| Field | Description |
| --- | --- |
| `city` / `state` / `address` / `country` | Location |
| `latitude` / `longitude` | Coordinates |
| `keywords` | Business keywords |
| `searchKeyword` | Source keyword |
| `scrapedAt` | Extraction timestamp |

***

### ⭐ What makes this scraper stand out

- **Direct contacts.** Email and phone come back on virtually every listing — most B2B scrapers can't provide this.
- **Business intelligence.** Manufacturer/exporter/trader flags, certifications and TrustStamp let you qualify suppliers fast.
- **De-duplicated, structured output** ready for spreadsheets, BI tools or your CRM.
- **Powerful filters** for manufacturers, exporters and verified suppliers.

***

### ✅ Proven results

A real run for `led light` returned 28 products/page (358 pages, ~22,000 products available) with **email, mobile, company, business type, city and member-since filled on 100% of records**, and price on ~85%. Verified live.

***

### 🔌 Integrations

Send TradeIndia data anywhere via Apify integrations and webhooks: **Google Sheets, Make, Zapier, Slack, CRMs/databases, or your own app** through the API.

***

### ▶️ How to use (step by step)

1. Click **Try for free** at the top of this page.
2. Add your keywords under `queries` in the Input tab.
3. Set `maxItemsPerQuery` and any filters.
4. Click **Start** and wait for the run to finish.
5. Download from the **Output / Dataset** tab as JSON, CSV or Excel, or pull via API.

Schedule the Actor to keep your supplier data fresh.

***

### ❓ FAQ

**Does it really include email and phone?**
Yes — TradeIndia publishes supplier email and mobile on its listings, and the scraper captures both, plus phone where available.

**How many products can I get?**
Popular keywords have hundreds of pages (e.g. `led light` had 358 pages / ~22,000 products). Set `maxItemsPerQuery` to your target.

**Can I filter to manufacturers or exporters?**
Yes — use `onlyManufacturers`, `onlyExporters` and `onlyTrustStamp`.

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

**Will I get duplicate products?**
No — results are de-duplicated by product ID.

**Does it need a login?**
No. It reads public search results — no account, no captcha.

**Is scraping TradeIndia legal?**
This Actor collects publicly available data. You are responsible for using it in compliance with TradeIndia's terms and applicable laws (including GDPR/data-protection rules where relevant — contact data especially).

**Can I run it on a schedule?**
Yes, via Apify Schedules.

***

### 💡 Tips & best practices

- **Use specific keywords** for relevant results; combine several for coverage.
- **Filter to exporters/manufacturers** for sourcing-grade leads.
- **Set a realistic `maxItemsPerQuery`** — 100–300 per keyword suits most projects.
- **Export to a spreadsheet** and sort by `priceValue` or filter by `businessTypes`.
- **Respect contact data** — comply with anti-spam and data-protection laws when using emails/phones.
- **Schedule recurring runs** to catch new suppliers and price changes.

***

### ⚠️ Limitations

- Price is shown only where the supplier publishes it; some listings have no price.
- Certifications appear only for suppliers that declare them.
- Contact data is public on TradeIndia but must be used lawfully.

***

### 🛠️ Example workflows

**Ready-to-contact lead list.** Run your target product keywords, push results to Google Sheets, and hand sales a list where every row has a company, email and phone — no contact-hunting needed.

**Sourcing shortlist.** Enable `onlyManufacturers` + `onlyExporters`, scrape a product across keywords, and rank suppliers by `memberSinceYears` and certifications to shortlist credible factories.

**Price benchmark.** Scrape one product, export to CSV, and analyze `priceValue` and `minOrderQuantity` across suppliers to understand market rates before negotiating.

**CRM enrichment.** Feed product/category keywords, capture supplier email, phone, location and business type, and sync to your CRM via Apify integrations.

**Competitor & market map.** Pull a whole category and chart suppliers by city, business type and certifications to map India's supply base for that product.

These run with zero code via Apify Schedules, integrations and webhooks.

### 🌐 About TradeIndia

TradeIndia is one of India's largest B2B marketplaces, connecting millions of buyers with manufacturers, exporters, traders and distributors across thousands of categories. For B2B prospecting it stands out because supplier **email and phone are published on listings** — making it one of the most actionable public B2B data sources for India. Whether you're sourcing products, building lead lists, benchmarking prices or researching the market, this scraper turns TradeIndia into a clean, contact-ready dataset in the format you need.

### ❓ More FAQ

**Can I get suppliers from a specific city?**
Append a city to your keyword (e.g. `led light delhi`) or filter the output by the `city` field after scraping.

**How do I focus on serious suppliers only?**
Combine `onlyTrustStamp` (verified) with `onlyManufacturers` or `onlyExporters`, and sort by `memberSinceYears` for established businesses.

**Can I scrape multiple products at once?**
Yes — add several keywords to `queries`; results are de-duplicated across them.

**What about pagination?**
Handled automatically — the scraper follows pages until it hits your `maxItemsPerQuery` or runs out of results.

**Does it return product specifications?**
Product name, description, category, brand and image are included; deeper specs live on detail pages.

**Can I export to my CRM or spreadsheet automatically?**
Yes — use Apify's native integrations (Google Sheets, HubSpot, Make, Zapier) or webhooks to push each run's results wherever you need them.

**How fresh is the data?**
Every run scrapes TradeIndia live, so prices, contacts and listings reflect the platform at run time. Schedule recurring runs to stay current.

**Can I find suppliers of a specific brand?**
Search the brand or product as a keyword; the `brandName` field is also captured where available.

### 📊 Data quality & coverage

This scraper is built for clean, analysis- and outreach-ready data:

- **Contact-complete.** Email and mobile come back on virtually every record — the field that makes TradeIndia uniquely valuable for B2B outreach.
- **De-duplicated by product ID.** Overlapping keywords never produce duplicate rows.
- **Numeric price.** `priceValue` is a real number alongside the display string, so you can sort, filter and average without cleanup.
- **Business intelligence built in.** Manufacturer / exporter / trader / distributor flags, certifications, TrustStamp and years-on-platform let you qualify suppliers instantly.
- **Server-rendered source.** Listings are server-rendered JSON, so extraction is fast and stable without a headless browser.

Every field is documented above and exports cleanly to JSON, CSV and Excel — dropping straight into spreadsheets, BI tools, your CRM or outreach platform.

### 📈 Scale & limits

- Popular keywords span hundreds of pages (e.g. `led light` had **358 pages / ~22,000 products**), so you can pull large, category-wide datasets.
- Pagination is automatic; set `maxItemsPerQuery` to control volume and cost.
- Combine multiple keywords for broad coverage, or narrow with filters for precision.
- Pricing is per result — you only pay for what you collect.

### ⚖️ Responsible use

TradeIndia publishes supplier contact details publicly, but you are responsible for using emails and phone numbers in line with anti-spam and data-protection laws (e.g. GDPR, CAN-SPAM, India's DPDP Act). Use the data for legitimate B2B outreach, sourcing and research — not unsolicited bulk spam.

### 🔄 How it compares

- **vs generic B2B scrapers** — TradeIndia exposes supplier **email and phone** on listings, so leads are contact-ready out of the box.
- **vs manual sourcing** — hundreds of de-duplicated, qualified supplier records in minutes, exportable to your CRM or spreadsheet.
- **vs paid lead databases** — fresh, live data straight from the source, priced per result.

Combine business-type and verification filters with `memberSinceYears` to focus on established, credible suppliers.

### 🚀 Get started

Click **Try for free**, enter a keyword like `led light`, and get a clean list of Indian suppliers — with prices, MOQ, **email and phone** — in minutes. Perfect for **B2B lead generation, sourcing and market research**.

# Actor input Schema

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

Product or category search terms as typed into TradeIndia search (e.g. "led light", "industrial valves", "cotton yarn").

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

Maximum products to collect per keyword. ~28 products per page, paginated automatically.

## `onlyManufacturers` (type: `boolean`):

Keep only suppliers flagged as manufacturers (filters out pure traders/distributors).

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

Keep only suppliers flagged as exporters. Ideal for international sourcing.

## `onlyTrustStamp` (type: `boolean`):

Keep only suppliers with TradeIndia's TrustStamp verification.

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

TradeIndia has no aggressive anti-bot; datacenter proxies work fine. A proxy is recommended for large runs.

## Actor input object example

```json
{
  "queries": [
    "led light",
    "industrial valves"
  ],
  "maxItemsPerQuery": 30,
  "onlyManufacturers": false,
  "onlyExporters": false,
  "onlyTrustStamp": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Clean JSON array of every scraped product with supplier details.

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

Spreadsheet-ready CSV.

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

Default dataset of this run.

# 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": [
        "led light"
    ],
    "maxItemsPerQuery": 30,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/tradeindia-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": ["led light"],
    "maxItemsPerQuery": 30,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/tradeindia-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": [
    "led light"
  ],
  "maxItemsPerQuery": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/tradeindia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradeIndia Scraper - B2B Suppliers, Prices, Email & Phone",
        "description": "Search TradeIndia.com and extract products with prices, MOQ, supplier email & phone, business type, certifications and verification for B2B lead generation.",
        "version": "1.0",
        "x-build-id": "gQe5CC7VwGM6wXoW8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~tradeindia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-tradeindia-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~tradeindia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-tradeindia-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~tradeindia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-tradeindia-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 keywords",
                        "type": "array",
                        "description": "Product or category search terms as typed into TradeIndia search (e.g. \"led light\", \"industrial valves\", \"cotton yarn\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum products to collect per keyword. ~28 products per page, paginated automatically.",
                        "default": 60
                    },
                    "onlyManufacturers": {
                        "title": "Only manufacturers",
                        "type": "boolean",
                        "description": "Keep only suppliers flagged as manufacturers (filters out pure traders/distributors).",
                        "default": false
                    },
                    "onlyExporters": {
                        "title": "Only exporters",
                        "type": "boolean",
                        "description": "Keep only suppliers flagged as exporters. Ideal for international sourcing.",
                        "default": false
                    },
                    "onlyTrustStamp": {
                        "title": "Only TrustStamp suppliers",
                        "type": "boolean",
                        "description": "Keep only suppliers with TradeIndia's TrustStamp verification.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "TradeIndia has no aggressive anti-bot; datacenter proxies work fine. A proxy is recommended for large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
