# Shopify Store Scraper - Find Merchants & Leads (`logiover/shopify-merchant-scraper`) Actor

Shopify store scraper and Shopify API alternative. Extract merchant emails, phones and social profiles, then export to CSV or JSON. No login required.

- **URL**: https://apify.com/logiover/shopify-merchant-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 25 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 verified shopify merchant leads

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

## 🛒 Shopify Store Scraper — Find Shopify Merchants & Extract Leads

![Shopify Merchant Scraper](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-FeWcTaXk4w2saftbV-WI2s1jmdnm-images.png)

Scrape any **Shopify store** for B2B merchant leads — store name, contact emails, phone numbers and social media profiles — using a raw HTTP engine that hits Shopify's JSON endpoints directly. This Shopify scraper skips slow headless browsers entirely, so it's fast, cheap, and built to process **thousands of store URLs per run**. No login and no API key required — just paste store URLs and run.

### ✨ What this Actor does / Key features

- 🚀 **No-browser architecture** — hits Shopify's internal JSON/data endpoints with raw HTTP. No page renders, no timeouts, just fast structured data.
- 📧 **Lead contact extraction** — pulls contact emails (primary + all found) and phone numbers (primary + all found) for B2B outreach.
- 🔗 **Social media profiles** — captures Facebook, Instagram and Twitter/X profile URLs for each store.
- 🏬 **Store intelligence** — extracts the official store name and clean domain from metadata and JSON-LD.
- 📦 **Product status detection** — reports whether the store's product catalog is active or hidden.
- 💰 **Extreme cost-efficiency** — consumes a fraction of the Compute Units of browser-based scrapers, lowering your price per lead.
- 📋 **Bulk processing** — feed a long list of Shopify store homepages and cap the run with a max-stores limit.
- 🛡️ **Proxy rotation** — built-in Apify Proxy support (residential recommended) to bypass rate limits at scale.
- 🔌 **Automation-friendly** — clean JSON output that plugs straight into n8n, Zapier, Make.com and custom API workflows.

### 🔍 Input

| Field | Type | Description |
|-------|------|-------------|
| `startUrls` | array | List of Shopify store homepages to extract leads from. **Required.** |
| `maxItems` | integer | Limit the total number of stores to scrape in this run. |
| `proxyConfiguration` | object | Proxy settings. Select proxy groups to bypass rate limits — residential is recommended. |

### 🚀 Example input

```json
{
  "startUrls": [
    { "url": "https://kyliecosmetics.com/" },
    { "url": "https://www.allbirds.com/" },
    { "url": "https://www.gymshark.com/" }
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

### 📦 Output

Each Shopify store is saved as a clean, machine-ready JSON item in the dataset. Export results to JSON, CSV, Excel, or HTML for your CRM and automation tools.

| Field | Description |
|-------|-------------|
| `storeName` | Official store name extracted from metadata and JSON-LD |
| `domain` | Clean hostname of the store |
| `email` | Primary verified contact email for B2B outreach |
| `emails` | Array of all contact emails found on the store |
| `phone` | Primary contact phone number |
| `phones` | Array of all phone numbers found |
| `facebook` | Facebook profile URL |
| `instagram` | Instagram profile URL |
| `twitter` | Twitter / X profile URL |
| `productCount` | Product catalog status (Active / Hidden) |
| `url` | Source URL that was scraped |
| `scrapedAt` | Precise timestamp of the extraction |

### 💡 Use cases

- **B2B lead generation** — build targeted lists of Shopify merchants with verified emails and phone numbers for cold outreach.
- **Sales & agency prospecting** — agencies offering apps, design, marketing or logistics services can source qualified Shopify store leads at scale.
- **Influencer & partnership outreach** — find Shopify brands and their social profiles for collaboration campaigns.
- **Market research** — analyze the Shopify ecosystem by domain, store name and product catalog status.
- **CRM enrichment** — enrich existing merchant records with contact details and social links.
- **Automation pipelines** — feed fresh merchant leads into n8n, Zapier or Make.com sales sequences.

### 🛠️ How it works

1. **Paste URLs** — add your target Shopify store homepages to `startUrls`.
2. **Set proxy** — choose residential proxies for high-volume, high-stability runs.
3. **Run** — the Actor queries each store's JSON endpoints directly and writes structured leads to your dataset.

### ❓ Frequently Asked Questions

**Is it legal to scrape Shopify stores?**
The Actor only collects publicly available business information that stores publish on their own websites (store name, public contact details, social links). You are responsible for using the data in compliance with applicable laws such as GDPR/CAN-SPAM and the target sites' terms. Consult your legal team for your specific use case.

**Do I need an API key or a login?**
No. There is no Shopify account, app install, or API key needed. You only need an Apify account to run the Actor and provide a list of store URLs.

**How many stores can I scrape in one run?**
The Actor is built for bulk processing — you can submit thousands of store URLs in a single run and use `maxItems` to cap the total. Because it uses raw HTTP instead of a browser, large runs stay fast and inexpensive.

**Will it find an email for every store?**
It extracts emails and phones that are publicly discoverable from the store's pages and structured data. Not every Shopify store publishes a contact email, so some records may have empty contact fields.

**Why is it cheaper than other Shopify scrapers?**
It uses a raw HTTP engine instead of a headless browser (Puppeteer/Playwright), which eliminates page-rendering overhead and consumes far fewer Compute Units — meaning a lower cost per lead.

**Does it handle rate limits and anti-bot protection?**
Yes. The Actor supports Apify Proxy with rotation; residential proxies are recommended for high-volume runs to maintain a high success rate.

**What output formats are supported?**
Results are stored in a structured Apify dataset and can be exported as JSON, CSV, Excel, or HTML, or pulled programmatically via the Apify API.

#### Is this a Shopify API alternative?

Yes. It works as a Shopify API alternative for collecting public merchant data — store name, domain, contact emails, phones and social profiles — by reading Shopify's public JSON endpoints directly, with no Shopify app, login or API key.

#### How do I export Shopify store data to CSV or JSON?

Run the Actor on your list of store URLs, then export the resulting dataset to CSV, JSON, Excel or HTML from the Apify console or API. It's a simple way to get a Shopify merchant dataset for your CRM.

#### Can I scrape Shopify stores without an API or login?

Yes. This Shopify data extraction tool needs no account on the target store and no API key. You only paste store homepage URLs and the raw HTTP engine pulls public emails, phones and social links.

### ⏰ Scheduling & integration

Schedule this Actor on Apify to refresh your merchant lead lists on any cadence. Output exports to JSON, CSV, Excel or HTML, and integrates directly with n8n, Zapier, Make.com, Google Sheets, webhooks and your CRM through the Apify API.

***

### Changelog

#### 2026-06-15

- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.

#### 2026-06-05

- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.

* **2026-06-01** — Maintenance & reliability pass: pulled the latest source and rebuilt the Actor on the current base image; build verified.

- **2026-05-25** — Maintenance & reliability pass: pulled the latest source and rebuilt the Actor on the current base image; build verified.

- **2026-05-20** — Maintenance pass: reviewed the input schema and default values for a smooth one-click start, and rebuilt the Actor on the latest base image.

*Last reviewed: 2026-06-01.*

### 📝 Changelog

#### 2026-06-07

- Docs: added coverage for Shopify API alternative, exporting Shopify store data to CSV/JSON, and scraping Shopify stores without an API or login.

#### 2026-06-04

- Verified live & refreshed build — reliability/maintenance pass.

# Actor input Schema

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

List of Shopify store homepages to extract leads from.

## `maxItems` (type: `integer`):

Limit the total number of stores to scrape in this run.

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

Select proxy groups to bypass rate limits. Residential is recommended.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://kyliecosmetics.com/"
    }
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://kyliecosmetics.com/"
        }
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/shopify-merchant-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 = {
    "startUrls": [{ "url": "https://kyliecosmetics.com/" }],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/shopify-merchant-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 '{
  "startUrls": [
    {
      "url": "https://kyliecosmetics.com/"
    }
  ],
  "maxItems": 100
}' |
apify call logiover/shopify-merchant-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Scraper - Find Merchants & Leads",
        "description": "Shopify store scraper and Shopify API alternative. Extract merchant emails, phones and social profiles, then export to CSV or JSON. No login required.",
        "version": "1.0",
        "x-build-id": "BCMQer3fecZjBXEw9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~shopify-merchant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-shopify-merchant-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/logiover~shopify-merchant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-shopify-merchant-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/logiover~shopify-merchant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-shopify-merchant-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Store URLs",
                        "type": "array",
                        "description": "List of Shopify store homepages to extract leads from.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Stores",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Limit the total number of stores to scrape in this run."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Settings",
                        "type": "object",
                        "description": "Select proxy groups to bypass rate limits. Residential is recommended.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
