# Shopify Store Leads & Intelligence (`thirdwatch/shopify-store-intelligence-scraper`) Actor

Discover Shopify stores by product keyword, then extract public websites, emails, phones, socials, ratings, sample products, technologies, and catalog intelligence. Direct store audits are also supported.

- **URL**: https://apify.com/thirdwatch/shopify-store-intelligence-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 shopify store leads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Shopify Store Leads & Intelligence

> Find Shopify stores by product keyword, enrich them with public contact and storefront data, or audit a list of known store URLs. No Shopify API key, login, browser, or merchant access is required.

### What this actor does

The actor supports two workflows:

- **Discover store leads:** Enter product keywords such as `organic coffee` or `yoga mats`. The actor searches Shop's public marketplace, deduplicates matching merchants, and enriches their public storefronts.
- **Audit known stores:** Enter Shopify domains or URLs to extract catalog, pricing, collection, theme, contact, and technology data.

Lead rows can include:

- Store name, recognized website, Shop profile, Shopify ID, and source query.
- Public email addresses, phone numbers, social profiles, and business address when published.
- Shop product rating and review totals.
- Two to ten sample products for lead qualification.
- Currency, theme, description, and common marketing technologies found on the storefront.

Direct store audits additionally include:

- Store-level audit summary with store name, description, currency, theme, product/variant/collection counts, vendors, product types, price range, sale rate, and availability.
- Public contact emails, phone links, social profiles, and common marketing technologies found on the storefront.
- Product-level results from Shopify's public `/products.json` endpoint.
- Variant, SKU, price, compare-at price, inventory availability, image, tag, and publish/update metadata.
- Optional public collection discovery from `/collections.json`.

It is built for DTC analysts, ecommerce operators, lead generation teams, agencies, investors, and price-monitoring workflows that need fast Shopify catalog visibility without running a browser.

### Why use it

- **No browser:** Shop discovery uses Chrome TLS fingerprinting plus server-rendered Apollo data at 256 MB.
- **Search without store URLs:** Start with a niche or product keyword instead of a prepared domain list.
- **Works with custom domains:** Use `brand.com`, `www.brand.com`, `brand.myshopify.com`, collection URLs, or product URLs.
- **Store audit + product feed:** Get one high-level audit row per store plus one row per product.
- **No credentials:** Uses only public storefront JSON endpoints.
- **Apify-ready output:** Dataset rows are structured for exports, integrations, and API consumption.

### Input

| Field | Required | Description |
|-------|----------|-------------|
| `queries` | No | Product keywords or niches used to discover Shopify store leads. |
| `maxStoresPerQuery` | No | Unique store leads per query. Default `25`, maximum `250`. |
| `sampleProductsPerLead` | No | Products embedded in each lead row. Default `3`, maximum `10`. |
| `storeUrls` | No | Shopify store homepages, product URLs, collection URLs, or myshopify.com URLs. |
| `storeDomains` | No | Plain domains such as `allbirds.com` or `gymshark.com`. Combined with `storeUrls`. |
| `maxProductsPerStore` | No | Maximum products to extract per store. Default `100`. |
| `includeCollections` | No | Fetch `/collections.json` where available. Default `true`. |
| `requestDelaySecs` | No | Polite delay between product pages. Default `0.5`. |
| `proxyConfiguration` | No | Residential proxy for Shop discovery and direct store audits. Lead enrichment requests remain direct to control cost. |

Provide at least one keyword, store URL, or store domain. Keyword and direct-audit inputs can be combined in one run.

### Example input

```json
{
  "queries": ["organic coffee", "mushroom coffee"],
  "maxStoresPerQuery": 25,
  "sampleProductsPerLead": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Output types

The dataset contains three result types.

#### Store lead result

One `store_lead` row is emitted for each unique discovered store. Missing contact fields are returned as empty arrays; the actor does not invent or guess email addresses.

```json
{
  "result_type": "store_lead",
  "source_query": "organic coffee",
  "store_name": "Example Coffee",
  "store_domain": "examplecoffee.com",
  "website_url": "https://examplecoffee.com/",
  "shop_url": "https://shop.app/m/examplecoffee",
  "contact_emails": ["hello@examplecoffee.com"],
  "contact_phones": ["+1 555 010 1234"],
  "social_links": ["https://instagram.com/examplecoffee"],
  "rating": 4.82,
  "total_product_reviews": 3995,
  "total_product_ratings": 15081,
  "technologies": ["Klaviyo", "Meta Pixel", "Shop Pay"],
  "sample_products": [
    {
      "title": "Organic Whole Bean Coffee",
      "price": 24.0,
      "currency": "USD",
      "url": "https://examplecoffee.com/products/organic-whole-bean"
    }
  ],
  "scraped_at": "2026-08-07T12:00:00+00:00"
}
```

#### Store audit result

One `store_audit` row is emitted per input store.

```json
{
  "result_type": "store_audit",
  "store_domain": "allbirds.com",
  "store_url": "https://www.allbirds.com/",
  "status": "shopify_detected",
  "products_found": 100,
  "collections_found": 24,
  "vendors": ["Allbirds"],
  "product_types": ["Accessories", "Shoes"],
  "price_min": 12.0,
  "price_max": 160.0,
  "available_products": 87,
  "products_on_sale": 14,
  "variants_found": 1260,
  "currency": "USD",
  "theme_name": "Allbirds",
  "contact_emails": ["help@example.com"],
  "social_links": ["https://instagram.com/example"],
  "technologies": ["Google Analytics", "Klaviyo", "Meta Pixel"],
  "sampled_at": "2026-06-03T10:00:00+00:00"
}
```

#### Product result

One `product_result` row is emitted per extracted Shopify product.

```json
{
  "result_type": "product_result",
  "store_domain": "allbirds.com",
  "store_url": "https://www.allbirds.com/",
  "url": "https://www.allbirds.com/products/mens-wool-runners",
  "product_id": 4029431775334,
  "handle": "mens-wool-runners",
  "title": "Men's Wool Runners",
  "vendor": "Allbirds",
  "product_type": "Shoes",
  "tags": ["mens", "wool"],
  "min_price": 110.0,
  "max_price": 110.0,
  "on_sale": false,
  "available": true,
  "variant_count": 24,
  "variants": [
    {"id": 123, "title": "10 / Natural Grey", "sku": "WR-NG-10", "price": "110.00", "available": true}
  ]
}
```

### Pricing event concept

This actor uses three Pay-Per-Event events:

| Event | Charged when | Why |
|-------|--------------|-----|
| `store_lead` | A unique Shopify store is discovered and enriched. | Lead discovery is priced separately from catalog export. |
| `store_audit` | A Shopify storefront is positively detected and an audit is produced. | Invalid, unreachable, and non-Shopify inputs are not charged. |
| `product_result` | A product row is extracted from `/products.json`. | Product-level catalog intelligence scales with result volume. |

### Use cases

- Competitive product catalog monitoring
- Shopify brand discovery and enrichment
- Price and sale tracking
- DTC lead qualification
- Investor and market mapping workflows
- Ecommerce agency audits
- Collection/category research

### Limitations

- Only public Shopify storefront data is extracted.
- Email, phone, address, and social coverage depends on what the merchant publishes. Empty arrays are valid results.
- Shop search is relevance-based. Alternate public sort views expand larger requests, but highly specific keywords can have fewer matching stores than the requested maximum.
- Some stores disable or restrict `/products.json`; those stores may return `no_public_products_found`.
- Shop discovery uses residential proxy traffic because Shop rate-limits Apify datacenter IPs. Storefront enrichment stays direct, so proxy use remains bounded to the search request.
- Inventory quantities are not exposed by Shopify's public product JSON; availability is boolean at variant level.
- This actor does not call private Shopify Admin APIs and does not bypass store protections.

### FAQ

**Do I need a Shopify API key?**
No. The actor uses public storefront JSON endpoints.

**Does this work on custom domains?**
Yes. Provide either custom domains or `myshopify.com` domains.

**Does it scrape collections?**
Yes, when `includeCollections` is enabled and the store exposes `/collections.json`.

**Is this browser-based?**
No. It is a pure HTTP actor designed for low cost and speed.

More ecommerce scrapers at [thirdwatch.dev](https://thirdwatch.dev).

# Actor input Schema

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

Discover Shopify stores without knowing their URLs. Enter products or niches such as 'organic coffee', 'yoga mats', or 'sustainable jewelry'. Results are discovered live from Shop's public marketplace and enriched from each public storefront.

## `maxStoresPerQuery` (type: `integer`):

Maximum unique Shopify store leads returned for each keyword. Larger requests use additional public Shop sort views and may take longer.

## `sampleProductsPerLead` (type: `integer`):

Number of public products included inside each store lead for qualification. Store-lead mode does not emit separate billable product rows.

## `storeUrls` (type: `array`):

Optional direct-audit mode: Shopify store homepages, product URLs, collection URLs, or myshopify.com URLs.

## `storeDomains` (type: `array`):

Plain domains to analyze, such as allbirds.com or gymshark.com. Combined with Store URLs.

## `maxProductsPerStore` (type: `integer`):

Maximum number of products to extract from each storefront.

## `includeCollections` (type: `boolean`):

Also fetch public collection metadata from /collections.json when available.

## `requestDelaySecs` (type: `number`):

Polite delay between paginated product requests for each store.

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

Residential proxy is used for the Shop discovery request because Shop rate-limits datacenter IPs. Per-store lead enrichment remains direct to control cost. Direct store-audit mode also uses this setting.

## Actor input object example

```json
{
  "queries": [
    "organic coffee"
  ],
  "maxStoresPerQuery": 25,
  "sampleProductsPerLead": 3,
  "storeUrls": [],
  "maxProductsPerStore": 100,
  "includeCollections": true,
  "requestDelaySecs": 0.5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "organic coffee"
    ],
    "storeUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/shopify-store-intelligence-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": ["organic coffee"],
    "storeUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/shopify-store-intelligence-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "organic coffee"
  ],
  "storeUrls": []
}' |
apify call thirdwatch/shopify-store-intelligence-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thirdwatch/shopify-store-intelligence-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6Sui25tNEiEeb3u2W/builds/1nvYsVZAkshsDDRdG/openapi.json