# ๐Ÿ›๏ธ Shopify Store Leads Scraper - Emails, Phones & Ratings (`scraper-engine/shopify-store-leads-scraper`) Actor Spotify Play Count Scraper extracts public track data including play counts, song titles, artists, albums, release dates, durations, and Spotify URLs. Monitor streaming performance, compare tracks, analyze music trends, and build structured datasets for research. - **URL**: https://apify.com/scraper-engine/shopify-store-leads-scraper.md - **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community) - **Categories:** - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.99 / 1,000 results This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. 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 Scraper - Emails, Phones & Ratings Shopify Store Leads Scraper - Emails, Phones & Ratings finds real, currently-operating Shopify stores by product keyword or category and returns structured lead data โ€” emails, phone numbers, business addresses, review ratings, and sample products โ€” as clean JSON, no HTML parsing needed. Every store streams into the dataset the moment it's enriched, split into ready-to-browse views for contacts, ratings, and products. Add a keyword below and start a run to see leads arrive in real time. ### ๐Ÿ” What is Shopify Store Leads Scraper - Emails, Phones & Ratings? Shopify Store Leads Scraper - Emails, Phones & Ratings is an Apify Actor that queries shop.app โ€” Shopify's own consumer shopping app โ€” to discover real Shopify-powered stores by product keyword and/or category, then enriches each unique store with its published contact channels, business address, review analytics, and sample products. It returns structured JSON with **no Shopify account, shop.app login, or API key required** โ€” the Actor mints its own guest session internally. It's built for growth/sales teams doing Shopify lead generation, dropship and wholesale sourcing, and market-research or AI/RAG pipelines that need a verified list of real Shopify merchants. ### ๐Ÿ“– What Shopify store data is publicly available to scrape? Every field this Actor returns is data a merchant chose to publish on shop.app โ€” the same public storefront data any shopper sees while browsing or searching the app, no login required. | Data Category | Published by the merchant on Shop.app | Not exposed by Shop.app | | --- | --- | --- | | Store name, website & myshopify.com domain | Always public | โ€” | | Business address (street, city, region, postal code, country) | Public only if the merchant added one | Blank when not published | | Contact channels (email, phone, web, social links) | Public only if the merchant listed them | Blank when not published | | Product review analytics (average rating, ratings count, reviews count) | Public | โ€” | | Sample product listings (title, price, currency, image) | Public โ€” up to 3 per store | Full catalog, exact stock levels | | Order history, customer records, sales/financial data | Never published on shop.app | Shopify admin login (store owner only) | Shopify Store Leads Scraper - Emails, Phones & Ratings only returns publicly visible data โ€” what any visitor to shop.app sees. Nothing behind a login wall. ### ๐Ÿ“Š What data can I extract with Shopify Store Leads Scraper - Emails, Phones & Ratings? The Actor returns one record per discovered Shopify store, covering its identity, published contacts and address, review analytics, and up to three sample products. | Field Name | Description | | --- | --- | | `id` | Shop.app's internal store identifier (opaque numeric string). | | `name` | The store's display name. | | `websiteUrl` | The store's live storefront URL (`utm_source=shop_app` kept; per-run session-tracking parameters stripped). | | `myshopifyDomain` | The store's underlying `*.myshopify.com` domain. | | `shareUrl` | The store's public shop.app share link. | | `address` | Business address object โ€” `null` when the merchant hasn't published one (see breakdown below). | | `contacts` | Array of every public contact channel the store lists โ€” `{ method, target }` pairs. | | `rating` | Average product rating across the store's catalog. | | `totalProductRatings` | Total number of product ratings behind that average. | | `totalProductReviews` | Total number of written product reviews. | | `sampleProducts` | Up to 3 real products sold by the store (see breakdown below). | | `scrapedAt` | ISO-8601 UTC timestamp of when this store record was collected. | | `searchQuery` | Which input search query surfaced this store โ€” `null` when discovered by category alone. | #### ๐Ÿฌ Store identity fields `id`, `name`, `websiteUrl`, `myshopifyDomain`, `shareUrl`, `searchQuery`, `scrapedAt` โ€” what the store is called, where it lives online, and which input run found it. #### ๐Ÿ“‡ Contact & address fields - **`contacts[]`** โ€” `method` (e.g. `email`, `phone`, `web`, `facebook`, `instagram` โ€” whatever channels the store itself publishes) and `target` (the email address, phone number, or URL). - **`address`** โ€” `address1`, `address2`, `city`, `zone`, `zoneCode`, `country`, `postalCode`, `company`, `phone`, and `formatted` (an array of pre-formatted display lines). #### โญ Ratings & sample products - **`rating`**, **`totalProductRatings`**, **`totalProductReviews`** โ€” review analytics for the store as a whole. - **`sampleProducts[]`** โ€” `title`, `price`, `currency`, `url`, `imageUrl` for up to 3 real products. ### ๐Ÿค” Why not build this yourself? Shop.app has no public developer API, and Shopify's own Admin and Storefront APIs are scoped to a single authenticated store โ€” neither one lets you search across the platform's stores by keyword or category. Building this yourself means reverse-engineering shop.app's internal GraphQL schema, keeping pace with its Remix-based asset bundling (endpoint paths have to be resolved live from hashed JS chunk names, since they're never literal strings in the bundle), and clearing its guest-session gate, which rejects plain HTTP clients **and** headless browsers alike โ€” only a real, visible Chrome session passes it. On top of that, you'd own proxy rotation and cost yourself. This Actor already handles all of it: live endpoint discovery every run, a real (Xvfb-backed) Chrome session for the one-time guest sign-in, and an automatic Direct โ†’ Datacenter โ†’ Residential proxy ladder that only spends a proxy tier when shop.app actually blocks a request. ### ๐Ÿš€ How to use Shopify Store Leads Scraper - Emails, Phones & Ratings This Actor runs on the Apify platform โ€” there's no separate signup or API key to obtain beyond an Apify account. 1. Open the Actor's page in the Apify Store and click **Try for free** (or **Start**, if you already have it). 2. Add at least one keyword to **๐Ÿ”Ž Search Queries (bulk)**, or pick a **๐Ÿ“‚ Category** โ€” the Actor needs one of the two to run; leaving both empty stops the run with a clear error. 3. Optionally narrow results with **๐Ÿ“ Store Location**, the **๐ŸŽ›๏ธ Product Filters** (price, on-sale, in-stock, ships-from/to), and **โญ๏ธ Skip Stores From Previous Runs**. 4. Click **โ–ถ๏ธ Start**. 5. Open the **Output** tab โ€” while the run is still going or after it finishes โ€” and export the results as JSON or CSV, or switch between the Overview, Contacts & Address, Ratings & Reviews, and Sample Products views. #### ๐Ÿ“ฆ How to scale to bulk store-lead extraction `searchQueries` is a bulk field (`stringList` editor) โ€” add as many keywords as you like and each is scraped as its own independent search, with every store streaming into the same dataset as it's found. `๐Ÿ“ฆ Max Stores (per query)` (`maxItems`) applies per keyword, so the run's ceiling is roughly `maxItems ร— number of queries`. There's no need to start separate runs for each keyword โ€” one run with a long `searchQueries` list covers all of them. ### ๐ŸŽฏ What can you do with Shopify store data? - ๐Ÿ“ˆ A growth marketer building a cold-outreach list uses `contacts` (the `email`/`phone` entries) and `name` to compile a verified list of Shopify merchants in one niche, without hand-collecting them from shop.app. - ๐Ÿค A wholesale/dropship sourcing manager combines `category` with `sampleProducts[].price` to shortlist Shopify stores selling in a niche at a target price point before reaching out. - ๐ŸŒ A regional sales rep uses `address.country` and the `shipsTo` filter to narrow leads down to stores based in, or shipping to, a specific target market. - ๐Ÿงช A market researcher compares `rating`, `totalProductRatings`, and `totalProductReviews` across competing stores in the same `category` to gauge review strength before entering a niche. - ๐Ÿค– An AI agent or RAG pipeline ingests the JSON output directly โ€” `name`, `address.formatted`, and `contacts` feed a lead-enrichment agent that drafts a personalized outreach message per store, with no HTML parsing or selectors involved. Because the output is typed, normalized JSON, any of these records can be handed straight to an agent framework or MCP client as tool output โ€” see Integrations below. ### ๐Ÿ›ก๏ธ How does Shopify Store Leads Scraper - Emails, Phones & Ratings handle rate limits and blocking? By default every request goes straight to shop.app with no proxy, which is enough for most runs. If shop.app starts rejecting requests, the Actor escalates itself automatically: Direct โ†’ ๐Ÿ–ฅ๏ธ Datacenter proxy โ†’ ๐Ÿ  Residential proxy, retrying the residential tier up to 3 times on a fresh IP before giving up on that one request; once residential is reached, the run stays on it for every remaining request (including the one-time Chrome session mint), and every switch is logged. Independently, `๐Ÿ” Max Retries Per Request` (`maxRetries`, default 3) controls how many times one request is retried on its *current* proxy tier, with a growing delay, before the Actor escalates to the next tier. The one-time guest session is minted with a real, visible Chrome session running under a virtual display, since shop.app's guest sign-in endpoint rejects both plain HTTP clients and headless browsers. If a single store's contacts/rating/sample-products fetch fails outright, that one store is skipped with a warning and the run continues; if shop.app becomes completely unreachable for 12 requests in a row, the Actor logs the failure clearly and stops instead of looping forever. The Actor does not solve CAPTCHAs. โš ๏ธ No proxy ladder can guarantee shop.app won't block a request โ€” the Direct โ†’ Datacenter โ†’ Residential escalation maximizes the chance of success but isn't a 100% guarantee. If a run keeps coming back with 0 stores, configure a Residential proxy explicitly in `proxyConfiguration` rather than relying on the automatic fallback alone. ### โฌ‡๏ธ Input | Parameter | Required | Type | Description | Example Value | | --- | --- | --- | --- | --- | | `searchQueries` | No | array | One or more product keywords to search for โ€” each is scraped as its own independent search and results stream into the same dataset. Leave empty to discover stores by Category alone. | `["wireless headphones", "organic coffee"]` | | `category` | No | string | Filter to stores selling in this product category; works alone or combined with a search query. Default `""` (no filter) โ€” one of 15 values (blank, or a `gid://shopify/ProductCategory/โ€ฆ` value), see below. | `"gid://shopify/ProductCategory/7"` | | `storeLocation` | No | string | Find stores based in a specific country or region. Stores with no published business address are still included as likely matches. Default `""` (any location) โ€” see the full list of regions/countries below. | `"US"` | | `maxItems` | No | integer | Maximum number of unique stores to return per search query. Default `10`, minimum `1`, maximum `100000`. | `50` | | `skipPreviouslyScraped` | No | boolean | Skip stores already returned in a previous run of the same search (query + category + store location + ships-to combination). Default `false`. | `true` | | `priceMin` | No | integer | Only discover stores selling products above this price (USD). Minimum `0`. | `20` | | `priceMax` | No | integer | Only discover stores selling products below this price (USD). Minimum `0`. | `100` | | `onSale` | No | boolean | Only discover stores with products currently on sale. Default `false`. | `true` | | `inStock` | No | boolean | Only discover stores with products currently in stock (matches shop.app's own default search behaviour). Default `true`. | `true` | | `shipsFrom` | No | boolean | Only discover stores that ship FROM the selected Store Location. Has no effect if Store Location is left as "Any location". Default `false`. | `true` | | `shipsTo` | No | string | Only discover stores that ship TO a specific destination country. Default `""` (any country) โ€” see the full list of country codes below. | `"GB"` | | `proxyConfiguration` | No | object | Default = no proxy (direct connection). Auto-escalates Direct โ†’ Datacenter โ†’ Residential if shop.app blocks requests; override to force a specific proxy from the start. Prefill: `{"useApifyProxy": false}`. | `{"useApifyProxy": false}` | | `maxRetries` | No | integer | How many times to retry one blocked/failed request on the same proxy tier before escalating to the next tier. Default `3`, minimum `1`, maximum `10`. | `3` | | `maxScanned` | No | integer | Safety cap on how many raw search result rows a single query may scan before giving up, even if `maxItems` hasn't been reached. Default `20000`, minimum `100`, maximum `200000`. | `20000` | โš ๏ธ `maxItems` defaults to `10` in the Apify Console UI, but the Actor's own code falls back to `50` if the field is omitted entirely (e.g. an API call that doesn't send it at all) rather than left at its schema default โ€” worth knowing if you call the Actor directly through the API without the Console form.
Full enum values for category, storeLocation, and shipsTo **`category`** โ€” `""` (๐Ÿšซ No category filter), `gid://shopify/ProductCategory/1` (๐Ÿ‘— Women), `gid://shopify/ProductCategory/2` (๐Ÿ‘” Men), `gid://shopify/ProductCategory/3` (๐Ÿ’ Accessories), `gid://shopify/ProductCategory/5` (๐Ÿ’„ Beauty), `gid://shopify/ProductCategory/6` (๐Ÿ  Home), `gid://shopify/ProductCategory/7` (๐Ÿ”Œ Electronics), `gid://shopify/ProductCategory/9` (๐Ÿงณ Luggage & bags), `gid://shopify/ProductCategory/10` (๐Ÿงธ Toys & games), `gid://shopify/ProductCategory/15` (๐Ÿพ Pet supplies), `gid://shopify/ProductCategory/69` (๐Ÿ‹๏ธ Fitness & nutrition), `gid://shopify/ProductCategory/209` (๐Ÿผ Baby & toddler), `gid://shopify/ProductCategory/251` (๐Ÿฝ๏ธ Food & drinks), `gid://shopify/ProductCategory/267` (โšฝ Sporting goods), `gid://shopify/ProductCategory/285` (๐ŸŽจ Arts & crafts) **`storeLocation`** โ€” `""` (๐ŸŒ Any location), `GLOBAL` (๐ŸŒ Global โ€” all markets), `ENGLISH_SPEAKING` (๐Ÿ—ฃ๏ธ English-speaking), `EUROPE` (๐Ÿ‡ช๐Ÿ‡บ Europe), `NORTH_AMERICA` (๐ŸŒŽ North America), `UK_IRELAND` (๐Ÿ‡ฌ๐Ÿ‡ง UK & Ireland), `NORDICS` (โ„๏ธ Nordics), `OCEANIA` (๐ŸŒ Oceania), `US` (๐Ÿ‡บ๐Ÿ‡ธ United States), `GB` (๐Ÿ‡ฌ๐Ÿ‡ง United Kingdom), `CA` (๐Ÿ‡จ๐Ÿ‡ฆ Canada), `AU` (๐Ÿ‡ฆ๐Ÿ‡บ Australia), `NZ` (๐Ÿ‡ณ๐Ÿ‡ฟ New Zealand), `IE` (๐Ÿ‡ฎ๐Ÿ‡ช Ireland), `DE` (๐Ÿ‡ฉ๐Ÿ‡ช Germany), `FR` (๐Ÿ‡ซ๐Ÿ‡ท France), `IT` (๐Ÿ‡ฎ๐Ÿ‡น Italy), `ES` (๐Ÿ‡ช๐Ÿ‡ธ Spain), `NL` (๐Ÿ‡ณ๐Ÿ‡ฑ Netherlands), `PL` (๐Ÿ‡ต๐Ÿ‡ฑ Poland), `AT` (๐Ÿ‡ฆ๐Ÿ‡น Austria), `CH` (๐Ÿ‡จ๐Ÿ‡ญ Switzerland), `PT` (๐Ÿ‡ต๐Ÿ‡น Portugal), `SE` (๐Ÿ‡ธ๐Ÿ‡ช Sweden), `DK` (๐Ÿ‡ฉ๐Ÿ‡ฐ Denmark), `FI` (๐Ÿ‡ซ๐Ÿ‡ฎ Finland) **`shipsTo`** โ€” `""` (๐ŸŒ Any country), `US` (๐Ÿ‡บ๐Ÿ‡ธ United States), `CA` (๐Ÿ‡จ๐Ÿ‡ฆ Canada), `GB` (๐Ÿ‡ฌ๐Ÿ‡ง United Kingdom), `AU` (๐Ÿ‡ฆ๐Ÿ‡บ Australia), `DE` (๐Ÿ‡ฉ๐Ÿ‡ช Germany), `FR` (๐Ÿ‡ซ๐Ÿ‡ท France), `IT` (๐Ÿ‡ฎ๐Ÿ‡น Italy), `ES` (๐Ÿ‡ช๐Ÿ‡ธ Spain), `NL` (๐Ÿ‡ณ๐Ÿ‡ฑ Netherlands), `BE` (๐Ÿ‡ง๐Ÿ‡ช Belgium), `AT` (๐Ÿ‡ฆ๐Ÿ‡น Austria), `CH` (๐Ÿ‡จ๐Ÿ‡ญ Switzerland), `SE` (๐Ÿ‡ธ๐Ÿ‡ช Sweden), `DK` (๐Ÿ‡ฉ๐Ÿ‡ฐ Denmark), `NO` (๐Ÿ‡ณ๐Ÿ‡ด Norway), `FI` (๐Ÿ‡ซ๐Ÿ‡ฎ Finland), `IE` (๐Ÿ‡ฎ๐Ÿ‡ช Ireland), `PT` (๐Ÿ‡ต๐Ÿ‡น Portugal), `PL` (๐Ÿ‡ต๐Ÿ‡ฑ Poland), `CZ` (๐Ÿ‡จ๐Ÿ‡ฟ Czech Republic), `RO` (๐Ÿ‡ท๐Ÿ‡ด Romania), `HU` (๐Ÿ‡ญ๐Ÿ‡บ Hungary), `GR` (๐Ÿ‡ฌ๐Ÿ‡ท Greece), `HR` (๐Ÿ‡ญ๐Ÿ‡ท Croatia), `BG` (๐Ÿ‡ง๐Ÿ‡ฌ Bulgaria), `SK` (๐Ÿ‡ธ๐Ÿ‡ฐ Slovakia), `SI` (๐Ÿ‡ธ๐Ÿ‡ฎ Slovenia), `LT` (๐Ÿ‡ฑ๐Ÿ‡น Lithuania), `LV` (๐Ÿ‡ฑ๐Ÿ‡ป Latvia), `EE` (๐Ÿ‡ช๐Ÿ‡ช Estonia), `IS` (๐Ÿ‡ฎ๐Ÿ‡ธ Iceland), `LU` (๐Ÿ‡ฑ๐Ÿ‡บ Luxembourg), `NZ` (๐Ÿ‡ณ๐Ÿ‡ฟ New Zealand), `JP` (๐Ÿ‡ฏ๐Ÿ‡ต Japan), `KR` (๐Ÿ‡ฐ๐Ÿ‡ท South Korea), `SG` (๐Ÿ‡ธ๐Ÿ‡ฌ Singapore), `HK` (๐Ÿ‡ญ๐Ÿ‡ฐ Hong Kong), `TW` (๐Ÿ‡น๐Ÿ‡ผ Taiwan), `MY` (๐Ÿ‡ฒ๐Ÿ‡พ Malaysia), `PH` (๐Ÿ‡ต๐Ÿ‡ญ Philippines), `TH` (๐Ÿ‡น๐Ÿ‡ญ Thailand), `ID` (๐Ÿ‡ฎ๐Ÿ‡ฉ Indonesia), `VN` (๐Ÿ‡ป๐Ÿ‡ณ Vietnam), `IN` (๐Ÿ‡ฎ๐Ÿ‡ณ India), `BR` (๐Ÿ‡ง๐Ÿ‡ท Brazil), `MX` (๐Ÿ‡ฒ๐Ÿ‡ฝ Mexico), `CO` (๐Ÿ‡จ๐Ÿ‡ด Colombia), `AR` (๐Ÿ‡ฆ๐Ÿ‡ท Argentina), `CL` (๐Ÿ‡จ๐Ÿ‡ฑ Chile), `ZA` (๐Ÿ‡ฟ๐Ÿ‡ฆ South Africa), `AE` (๐Ÿ‡ฆ๐Ÿ‡ช United Arab Emirates), `SA` (๐Ÿ‡ธ๐Ÿ‡ฆ Saudi Arabia), `IL` (๐Ÿ‡ฎ๐Ÿ‡ฑ Israel), `TR` (๐Ÿ‡น๐Ÿ‡ท Turkey), `NG` (๐Ÿ‡ณ๐Ÿ‡ฌ Nigeria), `EG` (๐Ÿ‡ช๐Ÿ‡ฌ Egypt), `KE` (๐Ÿ‡ฐ๐Ÿ‡ช Kenya)
#### Example input ```json { "searchQueries": ["wireless headphones", "organic coffee"], "category": "", "storeLocation": "US", "maxItems": 50, "skipPreviouslyScraped": true, "priceMin": 20, "priceMax": 100, "onSale": false, "inStock": true, "shipsFrom": false, "shipsTo": "", "proxyConfiguration": { "useApifyProxy": false }, "maxRetries": 3, "maxScanned": 20000 } ``` ### โฌ†๏ธ Output Every store is pushed to the dataset as typed, normalized JSON the moment it's enriched โ€” the field names stay the same across every run. Results are available as full JSON, through the per-section dataset views (Overview, Contacts & Address, Ratings & Reviews, Sample Products), or as a CSV export. #### Example output ```json { "id": "1235", "name": "JLab", "websiteUrl": "https://www.jlab.com?utm_source=shop_app", "myshopifyDomain": "jlabgrabbag.myshopify.com", "shareUrl": "https://shop.app/m/jlab?utm_source=shop_app", "address": { "address1": "5927 Landau Court", "address2": "", "city": "Carlsbad", "zone": "California", "zoneCode": "CA", "country": "US", "postalCode": "92008", "company": null, "phone": null, "formatted": ["5927 Landau Court", "Carlsbad, California 92008", "United States"] }, "contacts": [ { "method": "web", "target": "https://www.jlab.com?utm_source=shop_app" }, { "method": "facebook", "target": "https://www.facebook.com/JLabTech/" }, { "method": "instagram", "target": "https://www.instagram.com/jlabaudio" }, { "method": "email", "target": "support@jlab.com" }, { "method": "phone", "target": "405-445-7219" } ], "rating": 4.6127, "totalProductRatings": 7820, "totalProductReviews": 3932, "sampleProducts": [ { "title": "GO POP+ True Wireless Earbuds Black", "price": 24.99, "currency": "USD", "url": "https://www.jlab.com/products/go-pop-true-wireless-earbuds-black?utm_source=shop_app", "imageUrl": "https://cdn.shopify.com/s/files/1/0240/9337/files/GOPop_Black3.jpg?v=1762446393" } ], "scrapedAt": "2026-09-01T07:37:40.114187+00:00", "searchQuery": "wireless headphones" } ``` ### โš™๏ธ How does it work? Every run starts by fetching shop.app's live category taxonomy and endpoint paths from its own web bundle, rather than hardcoded values, so the Actor keeps working if shop.app renames a route. A one-time guest session is then minted using a real, visible Chrome browser under a virtual display โ€” shop.app's guest sign-in endpoint rejects both plain HTTP clients and headless browsers, so a genuinely non-headless session is required. Those cookies are handed to a fast, browser-impersonating HTTP client for every search and enrichment call, each carrying the same headers shop.app's own web client sends. If shop.app blocks a request, the Actor escalates through Datacenter and then Residential proxies automatically. Only data shop.app already serves publicly is returned, and output field names stay stable run over run, even if shop.app changes its layout. ### ๐Ÿ”Œ Integrations Shopify Store Leads Scraper - Emails, Phones & Ratings runs on the Apify platform, so it works with anything that can call the Apify API โ€” your own scripts, no-code automation tools, and AI agent frameworks. #### Calling Shopify Store Leads Scraper - Emails, Phones & Ratings programmatically ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("testt0/shopify-store-leads-scraper-emails-phones-ratings").call( run_input={"searchQueries": ["wireless headphones"], "maxItems": 20} ) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ``` Works in Go, Ruby, Node.js, cURL โ€” any language that can make an HTTP request to the Apify API. #### MCP integration for AI agents This Actor is reachable through Apify's own hosted MCP server โ€” no extra deployment needed. Point an MCP-compatible client at `https://mcp.apify.com?tools=testt0/shopify-store-leads-scraper-emails-phones-ratings`, or run it locally with `npx @apify/actors-mcp-server --tools actors,docs,testt0/shopify-store-leads-scraper-emails-phones-ratings` and an `APIFY_TOKEN` environment variable. Compatible clients include Claude Desktop, Claude Code, Cursor, and VS Code (GitHub Copilot). #### No-code tools (n8n, Make, LangChain) - **n8n** โ€” install `@apify/n8n-nodes-apify` and use its **Run Actor** action (with this Actor's ID) followed by **Get dataset items**, or a plain HTTP Request node against the run-sync-get-dataset-items endpoint. - **Make** โ€” use an HTTP module to call the Actor's `run-sync-get-dataset-items` endpoint with your Apify API token, the same way any REST integration is wired into a Make scenario. - **LangChain** โ€” use `ApifyWrapper().call_actor(actor_id="testt0/shopify-store-leads-scraper-emails-phones-ratings", run_input={...}, dataset_mapping_function=...)` to run the Actor and load its dataset straight into a LangChain document loader for RAG. ### โš–๏ธ Is it legal to scrape Shopify store leads? Scraping publicly available business information is generally legal in most jurisdictions, and Shopify Store Leads Scraper - Emails, Phones & Ratings returns only data merchants themselves chose to publish on shop.app โ€” nothing behind a login. The `contacts` and `address` fields this Actor collects are store-level business records (a support inbox, a company phone line, a registered business address) rather than data about a named individual, so this falls under standard **terms-of-service and database-rights** considerations rather than GDPR/CCPA's personal-data regime. That said, a sole trader whose published "business" email or phone is also their personal one could still bring that specific record within scope of GDPR/CCPA depending on your jurisdiction and use โ€” review your own use case accordingly. Consult legal counsel if your use case involves bulk storage of personal data. ### โ“ Frequently asked questions #### What Shopify store fields does Shopify Store Leads Scraper - Emails, Phones & Ratings return? The top fields are `contacts` (email, phone, social links), `address` (business address), `rating`/`totalProductRatings`/`totalProductReviews`, `sampleProducts`, and `websiteUrl`/`myshopifyDomain`. See What data can I extract above for the full list. #### Does Shopify Store Leads Scraper - Emails, Phones & Ratings require a Shopify account or login? No. The Actor mints its own guest session with shop.app internally โ€” you don't need a Shopify account, a shop.app login, or an API key to run it. #### How many Shopify stores can I extract in one run? `maxItems` caps unique stores per search query at up to 100,000, and `searchQueries` accepts multiple keywords in one run, so the run-wide ceiling is roughly `maxItems ร— number of queries`. A `maxScanned` safety cap (up to 200,000 raw result rows per query) stops a hopeless keyword from scanning forever even if `maxItems` isn't reached. #### What happens if a search query returns zero results? That query is logged as "0 stores found" and the run moves on to the next one โ€” it doesn't fail the whole run. If every query in a run returns nothing, the Actor logs a warning suggesting a broader keyword, fewer filters, or an explicit Residential proxy in case shop.app is blocking the run outright. #### Can I scrape multiple Shopify stores at once? Yes โ€” `searchQueries` is a bulk array field. Add as many keywords as you like in one run; each is searched independently and every discovered store streams into the same dataset. #### Does Shopify Store Leads Scraper - Emails, Phones & Ratings work with Claude, ChatGPT, and other AI agent tools? Yes. It's reachable through Apify's hosted MCP server (see Integrations above) for MCP-native clients like Claude Desktop and Claude Code, and callable as a plain HTTP endpoint by any other agent framework, including ChatGPT's custom-tool/Actions setups. #### Does Shopify Store Leads Scraper - Emails, Phones & Ratings avoid duplicate leads across runs? Yes, if you turn on `skipPreviouslyScraped`. Each unique search (keyword + category + store location + ships-to combination) keeps its own history in a named key-value store, so a later run of the same search returns only stores it hasn't returned before; price, availability, and shipping-origin filters don't start a new history. #### Does Shopify Store Leads Scraper - Emails, Phones & Ratings return data in a format LLMs can use directly? Yes. Typed, normalized JSON with consistent field names across runs โ€” no HTML parsing, no selectors. Pass it directly to an LLM, index it into a vector store, or feed it to an agent tool. #### What happens when shop.app changes its layout or anti-bot system? The Actor is maintained and its output field names stay stable. It also re-resolves its own endpoint paths and category taxonomy live at the start of every run rather than relying on hardcoded values, so it tolerates smaller shop.app changes (a renamed route, a new category) without needing a code update. #### Can I use Shopify Store Leads Scraper - Emails, Phones & Ratings without managing proxies or browser infrastructure? Yes. The Actor handles the one-time Chrome session mint (under a virtual display), the browser-impersonating HTTP client for search/enrichment calls, and the Direct โ†’ Datacenter โ†’ Residential proxy escalation itself โ€” you only need to touch `proxyConfiguration` if you want to force a specific tier from the start. #### Which Shopify store fields work best for AI training data and RAG indexing? For RAG, index the high-information text fields: `name`, `address.formatted`, `contacts`, and `sampleProducts[].title`. For training data, the most consistently structured fields are `rating`, `totalProductRatings`, `totalProductReviews`, and `sampleProducts[].price` โ€” all typed primitives (numbers, strings, or arrays of objects), never free-form HTML. ### ๐Ÿ”— Related scrapers | Scraper Name | What it extracts | | --- | --- | | Linkedin Profile Scraper with Email & Company Data | LinkedIn profiles enriched with contact emails and company details | | LinkedIn People Profile Scraper | LinkedIn people-profile data | | Naukri Job Scraper India Gulf Emails & 41 Fields | Job listings with recruiter emails across India and the Gulf | | Y Combinator Scraper | Y Combinator startup company records | ### ๐Ÿ’ฌ Your feedback Found a bug or missing a field? Let us know โ€” reach the Scraper Engine team at dev.scraperengine@gmail.com or open an issue from the Actor's page in Apify Store. Feedback on data quality and edge cases is always welcome. # Actor input Schema ## `searchQueries` (type: `array`): One or more product keywords to search for โ€” each is scraped as its own independent search and results stream into the same dataset. Leave empty to discover stores by ๐Ÿ“‚ Category alone. Examples: wireless headphones, organic coffee, yoga mat. ## `category` (type: `string`): Filter to stores selling in this product category. Works alone (discovers every store in the category) or combined with a search query above to narrow results. Applied to every query in this run. ## `storeLocation` (type: `string`): Find stores based in a specific country or region. Stores that don't publish a business address are still included as likely matches. For non-English markets, search using local-language keywords above (e.g. kerzen instead of candles) for the best results. ## `maxItems` (type: `integer`): Maximum number of unique stores to return for each search query above. ## `skipPreviouslyScraped` (type: `boolean`): Continue where your last run for this same search left off โ€” stores already returned before are skipped, so every run brings fresh leads. Each search (keyword + category + store location + ships-to combination) keeps its own history; price/availability/shipping-origin filters don't start a new one. Turn this on from your very first run. ## `priceMin` (type: `integer`): Only discover stores selling products above this price (USD). ## `priceMax` (type: `integer`): Only discover stores selling products below this price (USD). ## `onSale` (type: `boolean`): Only discover stores with products currently on sale. ## `inStock` (type: `boolean`): Only discover stores with products currently in stock. This matches shop.app's own default search behaviour. ## `shipsFrom` (type: `boolean`): Only discover stores that ship FROM the ๐Ÿ“ Store Location selected above. Has no effect if Store Location is left as "Any location". ## `shipsTo` (type: `string`): Only discover stores that ship TO a specific destination country. ## `proxyConfiguration` (type: `object`): ๐ŸŸข Default = no proxy (direct connection to shop.app), which works for most runs. If shop.app starts rejecting requests, the Actor automatically escalates itself: Direct โžœ ๐Ÿ–ฅ๏ธ Datacenter proxy โžœ ๐Ÿ  Residential proxy (retried up to 3ร— with a fresh IP), then stays on residential for the rest of the run. Every switch is logged clearly. Override this only to force a specific proxy from the start. ## `maxRetries` (type: `integer`): How many times to retry a single blocked/failed request (on the same proxy tier) before the Actor escalates to the next proxy tier. ## `maxScanned` (type: `integer`): Safety cap on how many raw search result rows a single query may scan through before giving up, even if 'Max Stores' hasn't been reached (protects against a runaway search on a hopeless keyword). ## Actor input object example ```json { "searchQueries": [ "wireless headphones" ], "category": "", "storeLocation": "", "maxItems": 10, "skipPreviouslyScraped": false, "onSale": false, "inStock": true, "shipsFrom": false, "shipsTo": "", "proxyConfiguration": { "useApifyProxy": false }, "maxRetries": 3, "maxScanned": 20000 } ``` # Actor output Schema ## `results` (type: `string`): Every scraped store, across every search query, in the order it was collected. ## `overview` (type: `string`): Quick-glance identity, rating, and website per store. ## `contacts` (type: `string`): Email, phone, social links, and business address per store. ## `ratings` (type: `string`): Review analytics per store. ## `products` (type: `string`): Sample products sold by each store. ## `csv` (type: `string`): All results exported as CSV. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "searchQueries": [ "wireless headphones" ], "proxyConfiguration": { "useApifyProxy": false } }; // Run the Actor and wait for it to finish const run = await client.actor("scraper-engine/shopify-store-leads-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "searchQueries": ["wireless headphones"], "proxyConfiguration": { "useApifyProxy": False }, } # Run the Actor and wait for it to finish run = client.actor("scraper-engine/shopify-store-leads-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 '{ "searchQueries": [ "wireless headphones" ], "proxyConfiguration": { "useApifyProxy": false } }' | apify call scraper-engine/shopify-store-leads-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraper-engine/shopify-store-leads-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 ` 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/3lZxoWmemq54brVAZ/builds/wY9OHKqguOGgE2ghB/openapi.json