# New Shopify Store Leads: Fresh Stores Daily with Emails (`scrapemint/new-shopify-store-leads`) Actor

Find Shopify stores launched in the last 1-7 days, before anyone else contacts them. One row per store: name, city, country, currency, product count, launched or still on the password page, owner email, phone, Instagram/TikTok/Facebook. Filter by country, keyword or TLD. WooCommerce optional.

- **URL**: https://apify.com/scrapemint/new-shopify-store-leads.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Lead generation, E-commerce
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 store lead with emails

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## New Shopify Store Leads: Fresh Stores Daily with Emails

Get a list of Shopify stores that were launched in the last few days, often before they have made their first sale, and before every other agency, app developer and supplier finds them. Each run scans the domains registered yesterday (or up to 7 days back), finds the ones pointing at Shopify, and opens each store to pull its name, location, currency, product count, launch status and contact details.

About 1,500-2,000 new Shopify stores appear in each day's list. Filter them by country, currency, domain keyword or TLD, and schedule the actor daily with `dedupe` on to get only stores you have not seen before.

No login, no API key, no browser, no proxy.

### Who uses it

- **Shopify agencies and freelancers**: theme setup, store design, CRO and ads for owners who are still building
- **Shopify app developers**: reach merchants in their first week, when they are installing apps
- **Suppliers, dropshipping and print-on-demand services**: new stores need products
- **Payment, shipping, email marketing and review apps**: onboard merchants before they pick a competitor
- **Market researchers**: how many new stores launch per country, niche and currency

### What you get

One row per store:

- `domain`, `url`, `registeredOn` (the day the domain was registered)
- `storeName`, `description`, `homepageTitle`
- `city`, `region`, `country`, `currency` (from the store's own Shopify settings)
- `productsCount`, `collectionsCount`, `shipsToCountries`, `shipsToCountriesCount`
- `launched`: `false` while the store is still behind Shopify's password page
- `email` (best pick), `emails`, `phones`
- `socials`: Instagram, Facebook, TikTok, YouTube, X, Pinterest, LinkedIn when linked
- `hasMx`, `emailProvider` (google_workspace, microsoft_365, zoho...)
- `myshopifyDomain`, `shopifyShopId`, `shopPayInstallments`, `platform`

Emails come from the homepage, the store's contact-information policy page (where Shopify asks merchants to list their contact details) and the contact page.

### Input

- `daysBack`: 1-7 daily lists, newest first. Default 1.
- `countries`: store address country codes, e.g. `US`, `GB`, `CA`, `AU`.
- `keywords`: keep domains containing a word, e.g. `pet`, `coffee`, `skin`.
- `tlds`: e.g. `com`, `shop`, `store`.
- `currencies`: e.g. `USD`, `EUR`.
- `minProducts`: skip stores with fewer published products.
- `onlyLaunched`: skip stores still on the password page.
- `requireEmail`: only stores with an email.
- `platforms`: `shopify` (default). Add `woocommerce` or `bigcommerce` to also fingerprint up to `maxSitesToFingerprint` other new sites per run.
- `maxStores`: default 100.
- `dedupe`: skip stores returned in earlier runs.

### Example input

```json
{
  "daysBack": 2,
  "countries": ["US", "CA"],
  "minProducts": 5,
  "requireEmail": true,
  "maxStores": 200,
  "dedupe": true
}
```

### Example output

```json
{
  "domain": "corelinewellness.com",
  "url": "https://corelinewellness.com",
  "platform": "shopify",
  "storeName": "Coreline Wellness",
  "city": "Del Mar",
  "region": "California",
  "country": "US",
  "currency": "USD",
  "productsCount": 153,
  "launched": true,
  "email": "support@corelinewellness.com",
  "emailProvider": "google_workspace",
  "registeredOn": "2026-11-04"
}
```

### Pricing

Pay per store: a higher rate for stores with an email, a lower rate for the rest. Turn on `requireEmail` to pay only for reachable stores. The first 2 rows of every run are free, and runs that match nothing cost nothing.

### Notes

- New stores are found by their domain's DNS pointing to Shopify. Stores that only use a `.myshopify.com` address, or that moved an older domain to Shopify, are not in the daily registration list.
- Email coverage depends on what the merchant has published. In a test of 12 new US stores, 4 had an email. Stores still on the password page rarely have one yet.
- The daily domain list comes from whoisds.com's free newly registered domains feed, published one day behind.
- Need more than stores? [Newly Registered Domain Leads](https://apify.com/scrapemint/newly-registered-domain-leads) gives every new domain by keyword, and [Website Tech Stack Detector](https://apify.com/scrapemint/website-tech-stack-detector) shows which apps a store runs.

# Actor input Schema

## `daysBack` (type: `integer`):

How many daily lists to scan, newest first (1 = domains registered yesterday). Each day adds roughly 1,500-2,000 new Shopify stores.

## `countries` (type: `array`):

Keep stores whose Shopify business address is in these countries. Two-letter codes, e.g. US, GB, CA, AU, DE.

## `keywords` (type: `array`):

Keep only domains containing one of these words, e.g. pet, coffee, skin, fitness, jewelry.

## `tlds` (type: `array`):

Keep only these domain endings, e.g. com, shop, store, co.uk.

## `currencies` (type: `array`):

Keep stores selling in these currencies, e.g. USD, EUR, GBP.

## `minProducts` (type: `integer`):

Skip stores with fewer published products. 0 keeps empty new stores too.

## `onlyLaunched` (type: `boolean`):

Skip stores still behind Shopify's password page (not open to shoppers yet). Leave off to reach owners while they are still building.

## `requireEmail` (type: `boolean`):

Skip stores where no email was found on the homepage, contact policy or contact page.

## `platforms` (type: `array`):

shopify (found by DNS, covers every new store), woocommerce, bigcommerce (found by fingerprinting a capped number of other new sites, see below).

## `maxSitesToFingerprint` (type: `integer`):

Only used for woocommerce or bigcommerce. How many non-Shopify live domains to open and check per run. Higher finds more stores but takes longer.

## `maxStores` (type: `integer`):

Cap on store rows. Controls cost.

## `dedupe` (type: `boolean`):

Remember returned stores across runs. Turn on for a daily scheduled lead feed.

## Actor input object example

```json
{
  "daysBack": 1,
  "countries": [
    "US"
  ],
  "keywords": [],
  "tlds": [],
  "currencies": [],
  "minProducts": 0,
  "onlyLaunched": false,
  "requireEmail": false,
  "platforms": [
    "shopify"
  ],
  "maxSitesToFingerprint": 1500,
  "maxStores": 100,
  "dedupe": false
}
```

# Actor output Schema

## `stores` (type: `string`):

Domain, store name, location, currency, product count, launch status, emails, phones, socials and email provider.

## `summary` (type: `string`):

Domains scanned, stores detected and rows written.

# 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 = {
    "countries": [
        "US"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/new-shopify-store-leads").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 = { "countries": ["US"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/new-shopify-store-leads").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 '{
  "countries": [
    "US"
  ]
}' |
apify call scrapemint/new-shopify-store-leads --silent --output-dataset

```

## MCP server setup

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

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/cL6QccZSLAgcHLhn7/builds/3dDIEjYMNQOPsab5F/openapi.json