# Ecommerce Store Lead Finder (`leadforge412/ecommerce-lead-finder-store-pain-signals-opportunity-score`) Actor

Find Shopify, WooCommerce, and ecommerce stores with visible growth signals. Detect platforms, marketing tools, public contacts, pain signals, product data, and lead scores.

- **URL**: https://apify.com/leadforge412/ecommerce-lead-finder-store-pain-signals-opportunity-score.md
- **Developed by:** [Mezhnun Orudzhaliev](https://apify.com/leadforge412) (community)
- **Categories:** Lead generation, E-commerce, SEO tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.

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

## Ecommerce Lead Finder — Store Pain Signals & Opportunity Score

Find ecommerce stores with visible public growth signals and turn them into qualified ecommerce prospecting records.

This Apify Actor analyzes public ecommerce websites, detects their ecommerce platform, identifies visible marketing and technology signals, extracts public business contact signals, samples product pages, and calculates a deterministic lead score.

It is designed for Shopify agencies, WooCommerce developers, CRO agencies, SEO agencies, paid ads agencies, email marketing teams, ecommerce SaaS companies, and B2B sales teams that need better ecommerce market research and prospect qualification.

Instead of returning only raw scraped website data, this Actor provides structured ecommerce intelligence:

- Ecommerce platform detection
- Marketing technology detection
- Missing visible tool signals
- Store pain signals
- Product count estimates
- Product availability signals
- Public business contact signals
- Lead score
- Reason to review the account

---

### What This Ecommerce Scraper Does

The Actor accepts ecommerce store domains or start URLs and analyzes each public storefront.

It can detect ecommerce platforms such as:

- Shopify
- WooCommerce
- Magento
- BigCommerce
- Wix
- Squarespace
- Ecwid
- Custom ecommerce websites
- Unknown ecommerce platforms

It can also detect public evidence of marketing, analytics, ecommerce, and customer support technologies, including:

- Meta Pixel
- TikTok Pixel
- Google Tag Manager
- Google Analytics / GA4
- Klaviyo
- Omnisend
- Mailchimp
- Yotpo
- Judge.me
- Loox
- Stamped.io
- Recharge
- Gorgias
- Zendesk
- Intercom
- Tawk.to
- Hotjar
- PostHog

The Actor then identifies visible public signals that may be useful for ecommerce research, sales research, market mapping, prospecting research, account qualification, competitive research, or business development workflows.

---

### Who Should Use This Actor

This ecommerce lead generation and prospecting research scraper is useful for:

- Shopify agencies looking for ecommerce prospecting data
- WooCommerce developers researching stores that may need improvements
- CRO agencies researching stores without visible reviews, live chat, or strong product page signals
- SEO agencies researching ecommerce websites with weak metadata or missing product schema evidence
- Paid ads agencies researching stores without visible Meta Pixel or TikTok Pixel evidence
- Email marketing agencies researching stores without visible email capture evidence
- Ecommerce SaaS teams researching qualified accounts
- B2B sales teams building targeted ecommerce account lists
- Freelancers selling Shopify, SEO, CRO, email marketing, or paid ads services
- Market researchers mapping ecommerce technology adoption

The Actor helps identify ecommerce stores that show public signs worth reviewing further.

---

### Common Use Cases

#### Shopify Lead Generation Research

Find Shopify stores that may be relevant for marketing, CRO, SEO, or development research.

Example use case:

> Find Shopify stores that do not appear to show visible evidence of TikTok Pixel, product reviews, or live chat.

---

#### Ecommerce Agency Prospecting Research

Build structured ecommerce prospecting datasets for agencies and freelancers.

Example use case:

> Find ecommerce stores with visible missing growth tool signals and generate a deterministic account review note for each store.

---

#### Paid Ads Account Research

Find ecommerce stores where visible public tracking pixel evidence was not detected.

Example use case:

> Find stores where the Actor does not detect visible Meta Pixel or TikTok Pixel evidence and review them for paid social readiness.

---

#### CRO Research

Find ecommerce websites with visible conversion-related signals worth reviewing.

Example use case:

> Find stores without visible product reviews, live chat, email capture, or product schema evidence.

---

#### SEO Research for Ecommerce

Find ecommerce stores with public SEO signals worth reviewing.

Example use case:

> Find stores with weak meta titles, weak meta descriptions, or missing product schema evidence.

---

#### Ecommerce SaaS Account Qualification

Find potential ecommerce SaaS accounts based on visible public technology signals.

Example use case:

> Find Shopify or WooCommerce stores that do not appear to use visible review platforms, live chat widgets, email marketing tools, or subscription apps.

---

### Input

You can provide either domains or start URLs.

#### Example Input

```json
{
  "domains": [
    "gymshark.com",
    "allbirds.com",
    "colourpop.com"
  ],
  "startUrls": [],
  "maxDomains": 3,
  "maxPagesPerDomain": 20,
  "maxProductsPerDomain": 10,
  "enabledSignals": [
    "tracking_pixels",
    "reviews",
    "live_chat",
    "email_capture",
    "seo",
    "availability",
    "contact"
  ],
  "includePersonalEmails": false,
  "useBrowser": "auto",
  "debugMode": false
}
````

***

### Input Fields

| Field | Type | Description |
|---|---|---|
| `domains` | array | List of store domains to analyze. Example: `allbirds.com` |
| `startUrls` | array | List of full URLs to start from |
| `maxDomains` | number | Maximum number of domains to analyze |
| `maxPagesPerDomain` | number | Maximum pages to crawl per domain |
| `maxProductsPerDomain` | number | Maximum product pages to sample per domain |
| `enabledSignals` | array | Types of signals to detect |
| `includePersonalEmails` | boolean | Whether to include personal-looking emails. Default: `false` |
| `useBrowser` | string | Browser mode: `never`, `auto`, or `always` |
| `debugMode` | boolean | Enables more detailed logs |

***

### Output

Each dataset item represents one analyzed ecommerce domain.

#### Example Output

```json
{
  "domain": "allbirds.com",
  "finalUrl": "https://www.allbirds.com/",
  "storeName": "Allbirds",
  "platform": "Shopify",
  "platformConfidence": 0.99,
  "country": "United States",
  "language": "en-us",
  "niche": "Apparel",
  "detectedTechnologies": [
    "Google Tag Manager",
    "Yotpo"
  ],
  "missingTechnologies": [
    "Meta Pixel",
    "TikTok Pixel",
    "Klaviyo",
    "Omnisend",
    "Mailchimp",
    "Gorgias"
  ],
  "painSignals": [
    "missing_meta_pixel",
    "missing_tiktok_pixel",
    "missing_schema_product",
    "no_public_email"
  ],
  "productCountEstimate": 67,
  "sampledProductCount": 10,
  "outOfStockRatio": 0,
  "hasContactPage": true,
  "contactPageUrl": "https://www.allbirds.com/pages/help",
  "genericEmails": [],
  "socialLinks": {
    "instagram": [
      "https://www.instagram.com/allbirds"
    ],
    "tiktok": [
      "https://www.tiktok.com/@weareallbirds"
    ],
    "facebook": [
      "https://www.facebook.com/weareallbirds"
    ],
    "linkedin": [],
    "x": [
      "https://twitter.com/allbirds"
    ],
    "youtube": []
  },
  "seo": {
    "title": "Allbirds: Comfortable, Sustainable Shoes & Apparel",
    "metaDescription": "Allbirds: The world’s most comfortable shoes, flats, and clothing made with natural materials like merino wool and eucalyptus.",
    "canonical": "https://www.allbirds.com/",
    "hasSchemaProduct": false,
    "titleLength": 50,
    "metaDescriptionLength": 151
  },
  "leadScore": 60,
  "scoreBreakdown": {
    "base": 20,
    "signalWeights": {
      "missing_meta_pixel": 8,
      "missing_tiktok_pixel": 5,
      "missing_schema_product": 6,
      "no_public_email": -4
    },
    "qualification": {
      "ecommerceEvidence": 12,
      "reachableBusiness": 4,
      "productDepth": 10,
      "crawlQuality": 0
    },
    "rawScore": 60,
    "cappedScore": 60
  },
  "reasonToContact": "Allbirds looks like a relevant account to review because it does not appear to show visible Meta Pixel evidence, does not appear to show visible TikTok Pixel evidence, and product schema was not detected.",
  "analyzedAt": "2026-05-03T12:00:00.000Z",
  "errors": []
}
```

***

### Output Fields

| Field | Description |
|---|---|
| `domain` | Original domain from input |
| `finalUrl` | Final storefront URL after redirects and recovery |
| `storeName` | Detected store or brand name |
| `platform` | Ecommerce platform such as Shopify, WooCommerce, Magento, BigCommerce, Wix, Squarespace, or Unknown |
| `platformConfidence` | Confidence score for platform detection |
| `country` | Inferred country when available |
| `language` | Detected or inferred page language |
| `niche` | Inferred ecommerce niche |
| `detectedTechnologies` | Marketing and ecommerce tools detected on the website |
| `missingTechnologies` | Important tools where visible evidence was not detected |
| `painSignals` | Growth, technical, SEO, or operational signals detected from public evidence |
| `productCountEstimate` | Estimated number of product pages |
| `sampledProductCount` | Number of product pages sampled |
| `outOfStockRatio` | Ratio of sampled products with strong out-of-stock evidence |
| `hasContactPage` | Whether a contact page was found |
| `contactPageUrl` | Public contact page URL |
| `genericEmails` | Public generic business emails such as `support@`, `hello@`, or `info@` |
| `socialLinks` | Public social media links |
| `seo` | SEO metadata and product schema signals |
| `leadScore` | Deterministic opportunity score from 0 to 100 |
| `scoreBreakdown` | Explanation of how the lead score was calculated |
| `reasonToContact` | Short deterministic account review note |
| `errors` | Non-fatal crawl warnings or errors |

***

### Pain Signals Explained

The Actor detects public ecommerce pain signals that may indicate a store is worth reviewing for growth, marketing, analytics, SEO, or conversion optimization research.

Examples:

| Pain signal | Meaning |
|---|---|
| `missing_meta_pixel` | Visible Meta Pixel evidence was not detected |
| `missing_tiktok_pixel` | Visible TikTok Pixel evidence was not detected |
| `missing_google_analytics` | Visible Google Analytics / GA4 evidence was not detected |
| `missing_email_capture` | No visible email capture or newsletter form was detected |
| `missing_reviews` | No visible product review widget was detected |
| `missing_live_chat` | No visible live chat widget was detected |
| `missing_schema_product` | Product schema was not detected |
| `weak_meta_title` | Homepage title appears weak or missing |
| `weak_meta_description` | Meta description appears weak or missing |
| `low_product_count` | Product count appears low |
| `high_out_of_stock_ratio` | Strong out-of-stock evidence was found in sampled products |
| `no_contact_page` | No contact page was found |
| `no_public_email` | No generic public business email was found |
| `no_social_links` | No social links were found |
| `no_blog` | No blog or content section was found |

***

### Lead Score Explained

The `leadScore` is a deterministic score from 0 to 100.

It considers:

- Ecommerce platform evidence
- Product page evidence
- Contactability
- Visible missing growth tool signals
- Visible marketing pixel evidence
- Visible review platform evidence
- Visible live chat evidence
- SEO signals
- Product availability signals
- Crawl quality

A higher score means the store may be a stronger account to review for ecommerce prospecting research.

The score is not generated by AI and does not rely on external enrichment. It is calculated from visible public website evidence.

***

### Browser Fallback

The Actor uses fast static HTML crawling by default.

When static crawling produces weak evidence and `useBrowser` is set to `auto`, the Actor can use Playwright browser rendering as a fallback for JavaScript-heavy storefronts.

Supported browser modes:

| Mode | Description |
|---|---|
| `never` | Only use static HTML crawling |
| `auto` | Use browser fallback when static evidence is weak |
| `always` | Always use browser rendering where supported |

For most use cases, `auto` is recommended.

***

### Checkout Redirect Recovery

Some ecommerce stores redirect root domains to checkout, regional, or payment-related URLs.

This Actor attempts to detect and recover from checkout, cart, payment, and billing redirects.

If a domain redirects to a checkout subdomain, the Actor can try to recover the real storefront URL and store warnings in the `errors` field instead of incorrectly analyzing the checkout page.

***

### Public Business Contact Extraction

By default, the Actor extracts only generic public business emails such as:

- `info@`
- `support@`
- `hello@`
- `contact@`
- `sales@`
- `team@`
- `service@`

Personal-looking emails are excluded by default.

This makes the output more suitable for B2B prospecting research and account qualification workflows.

***

### How to Use the Results

You can use the dataset for:

- Ecommerce lead generation research
- Shopify agency prospecting research
- WooCommerce agency prospecting research
- SEO prospecting research
- CRO prospecting research
- Paid ads account research
- Email marketing account research
- Ecommerce SaaS account qualification
- Competitive research
- Market mapping
- CRM enrichment
- Google Sheets workflows
- Clay workflows
- Make or Zapier automation
- HubSpot or Airtable import

***

### Example Sales Research Angles

A paid ads team could use this Actor to review stores where visible Meta Pixel or TikTok Pixel evidence was not detected.

Example research note:

> The store does not appear to show visible Meta Pixel or TikTok Pixel evidence. This may be relevant for teams evaluating paid social tracking, retargeting, or analytics readiness.

A CRO team could use this Actor to review stores where visible product review or live chat evidence was not detected.

Example research note:

> The product pages do not appear to show a visible review widget or live chat. These may be relevant trust and conversion signals to review.

An email marketing team could use this Actor to review stores where visible email capture evidence was not detected.

Example research note:

> The store does not appear to show visible email capture evidence. This may be relevant for teams evaluating owned audience growth and lifecycle marketing readiness.

***

### Pricing

This Actor can be used with Apify platform usage pricing or pay-per-event pricing depending on the published configuration.

Actual costs may depend on crawl depth, browser rendering usage, proxy usage, and enrichment level.

***

### Limitations

This Actor analyzes public website evidence only.

It may miss tools or signals that are:

- Hidden behind consent banners
- Loaded after delayed JavaScript interactions
- Region-specific
- Blocked by bot protection
- Hidden behind login
- Loaded only after user consent
- Present only on checkout pages
- Present only in specific countries or sessions

Product count is an estimate based on discovered product URLs, sitemaps, Shopify product endpoints, and crawled pages.

Out-of-stock detection is conservative and requires strong evidence such as explicit JSON-LD availability, sold-out text, or disabled sold-out controls.

Some live ecommerce websites may return 403 or 429 responses. The Actor preserves these as non-fatal errors where possible.

***

### Ethical and Legal Notes

This Actor is designed to analyze publicly available ecommerce website data.

It does not require login credentials.

It does not scrape private dashboards, customer accounts, payment pages, or hidden data.

By default, it excludes personal-looking email addresses and focuses on generic public business contacts.

Users are responsible for ensuring that their use of the Actor complies with applicable laws, website terms, privacy rules, and outreach regulations.

***

### Local Development

Install dependencies:

```bash
npm install
```

Build the project:

```bash
npm run build
```

Run tests:

```bash
npm test
```

Run lint:

```bash
npm run lint
```

Run the local fixture test:

```bash
npm run run:fixture
```

Run locally with Apify storage input:

```bash
npm run start
```

***

### Example Local Input

Edit:

```text
storage/key_value_stores/default/INPUT.json
```

Example:

```json
{
  "domains": [
    "gymshark.com",
    "allbirds.com",
    "colourpop.com"
  ],
  "startUrls": [],
  "maxDomains": 3,
  "maxPagesPerDomain": 20,
  "maxProductsPerDomain": 10,
  "enabledSignals": [
    "tracking_pixels",
    "reviews",
    "live_chat",
    "email_capture",
    "seo",
    "availability",
    "contact"
  ],
  "includePersonalEmails": false,
  "useBrowser": "auto",
  "debugMode": true
}
```

***

### SEO Keywords

This Actor is relevant for users searching for:

- ecommerce scraper
- Shopify scraper
- Shopify lead finder
- Shopify lead generation
- WooCommerce scraper
- WooCommerce lead generation
- ecommerce lead generation
- ecommerce prospecting tool
- ecommerce store scraper
- ecommerce technology detector
- ecommerce website audit scraper
- DTC brand lead finder
- store lead finder
- Shopify agency leads
- CRO agency leads
- SEO lead generation for ecommerce
- paid ads lead generation
- email marketing lead generation
- ecommerce pain signals
- ecommerce lead scoring
- ecommerce opportunity score
- ecommerce B2B leads
- public ecommerce data scraper

# Actor input Schema

## `domains` (type: `array`):

Bare domains or full URLs to analyze. Bare domains default to HTTPS.

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

Explicit ecommerce store URLs to analyze.

## `maxDomains` (type: `integer`):

Maximum unique domains to analyze.

## `maxPagesPerDomain` (type: `integer`):

Hard crawl budget per domain.

## `maxProductsPerDomain` (type: `integer`):

Maximum number of product pages or product records sampled per store.

## `enabledSignals` (type: `array`):

Optional list of pain signal IDs or signal groups to include. Examples: tracking\_pixels, reviews, live\_chat, email\_capture, seo, availability, contact. Empty means all signals.

## `includePersonalEmails` (type: `boolean`):

Disabled by default. When disabled, only generic business inboxes are emitted.

## `useBrowser` (type: `string`):

Use Playwright for JavaScript-heavy pages.

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

Apify proxy configuration.

## `debugMode` (type: `boolean`):

Enable verbose crawl logs.

## Actor input object example

```json
{
  "maxDomains": 25,
  "maxPagesPerDomain": 20,
  "maxProductsPerDomain": 10,
  "includePersonalEmails": false,
  "useBrowser": "auto",
  "debugMode": false
}
```

# Actor output Schema

## `results` (type: `string`):

Analyzed ecommerce store records stored in the default dataset.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("leadforge412/ecommerce-lead-finder-store-pain-signals-opportunity-score").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("leadforge412/ecommerce-lead-finder-store-pain-signals-opportunity-score").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 '{}' |
apify call leadforge412/ecommerce-lead-finder-store-pain-signals-opportunity-score --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=leadforge412/ecommerce-lead-finder-store-pain-signals-opportunity-score",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ecommerce Store Lead Finder",
        "description": "Find Shopify, WooCommerce, and ecommerce stores with visible growth signals. Detect platforms, marketing tools, public contacts, pain signals, product data, and lead scores.",
        "version": "1.0",
        "x-build-id": "3vX98Z07o386HkVG8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/leadforge412~ecommerce-lead-finder-store-pain-signals-opportunity-score/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-leadforge412-ecommerce-lead-finder-store-pain-signals-opportunity-score",
                "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/leadforge412~ecommerce-lead-finder-store-pain-signals-opportunity-score/runs": {
            "post": {
                "operationId": "runs-sync-leadforge412-ecommerce-lead-finder-store-pain-signals-opportunity-score",
                "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/leadforge412~ecommerce-lead-finder-store-pain-signals-opportunity-score/run-sync": {
            "post": {
                "operationId": "run-sync-leadforge412-ecommerce-lead-finder-store-pain-signals-opportunity-score",
                "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",
                "properties": {
                    "domains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "Bare domains or full URLs to analyze. Bare domains default to HTTPS.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Explicit ecommerce store URLs to analyze.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Public ecommerce storefront URL to analyze, for example https://www.example-store.com/."
                                }
                            }
                        }
                    },
                    "maxDomains": {
                        "title": "Maximum domains",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique domains to analyze.",
                        "default": 25
                    },
                    "maxPagesPerDomain": {
                        "title": "Maximum pages per domain",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard crawl budget per domain.",
                        "default": 20
                    },
                    "maxProductsPerDomain": {
                        "title": "Maximum sampled products per domain",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of product pages or product records sampled per store.",
                        "default": 10
                    },
                    "enabledSignals": {
                        "title": "Enabled pain signals",
                        "type": "array",
                        "description": "Optional list of pain signal IDs or signal groups to include. Examples: tracking_pixels, reviews, live_chat, email_capture, seo, availability, contact. Empty means all signals.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePersonalEmails": {
                        "title": "Include personal-looking emails",
                        "type": "boolean",
                        "description": "Disabled by default. When disabled, only generic business inboxes are emitted.",
                        "default": false
                    },
                    "useBrowser": {
                        "title": "Browser rendering",
                        "enum": [
                            "never",
                            "auto",
                            "always"
                        ],
                        "type": "string",
                        "description": "Use Playwright for JavaScript-heavy pages.",
                        "default": "auto"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration."
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable verbose crawl logs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
