# Shopify Store Finder: Top Shopify Stores by Popularity (`storesignal/shopify-store-finder`) Actor

Search a ranked database of popular Shopify stores. Filter by country, currency, keywords, domain extension, traffic rank and catalog size. Pay only for stores returned.

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

## Pricing

$3.00 / 1,000 store listeds

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

## Shopify Store Finder

Search a ranked database of popular Shopify stores. Filter by country, currency, keywords, domain extension, traffic rank and catalog size, and get a clean list of store domains with metadata. Results are ordered by popularity.

The database holds 57,202 Shopify stores and was last updated on 2026-11-13. The Actor makes no network requests when it runs: it filters a database bundled with it, so runs finish in seconds.

### What you get

For every matching store:

| Field | Description |
|---|---|
| `domain`, `url` | Store domain (without `www.`) and `https://` URL |
| `tld` | Public suffix, for example `com` or `co.uk` |
| `trafficRank` | Chrome UX Report popularity bucket (1000, 5000, 10000, 50000, 100000, 500000, 1000000), or `null` |
| `majesticRank` | Position in the Majestic Million, or `null` |
| `name`, `description` | Store name and description from the store's public metadata |
| `country`, `currency`, `city` | Store location and currency from the same metadata |
| `productCount` | Number of published products. Shopify caps this value at 25001, which means "more than 25,000" |
| `myshopifyDomain` | The store's `*.myshopify.com` domain |
| `dataUpdatedAt` | Date of the database snapshot |

Fields the store does not publish are `null`.

### Input

| Field | Description |
|---|---|
| `maxResults` | Stores to return, 1 to 100000 (default 100) |
| `offset` | Matching stores to skip, for paging |
| `countries` | Two-letter ISO country codes, e.g. `US`, `GB` |
| `currencies` | Currency codes, e.g. `USD`, `EUR` |
| `keywords` | Case-insensitive substrings matched in name, description or domain. Any keyword is enough |
| `tlds` | Domain extensions, e.g. `com`, `co.uk`, `de` (leading dot optional) |
| `maxTrafficRank` | Only stores in the top N popularity bucket (Top 1,000 to Top 1,000,000) |
| `maxMajesticRank` | Only stores with Majestic rank at or below this value |
| `minProducts`, `maxProducts` | Catalog size range |

Empty filters mean no restriction. A filter on a field skips stores where that field is `null`. Order is the same on every run: traffic rank ascending, then Majestic rank, then domain. Use `offset` and `maxResults` to page.

Example input: German-language-market coffee stores in the top 100,000.

```json
{
  "maxResults": 200,
  "countries": ["DE"],
  "keywords": ["coffee", "kaffee"],
  "maxTrafficRank": "100000"
}
```

Example output record:

```json
{
  "domain": "example-coffee.com",
  "url": "https://example-coffee.com",
  "tld": "com",
  "trafficRank": 10000,
  "majesticRank": 48213,
  "name": "Example Coffee",
  "description": "Specialty coffee and brewing gear.",
  "country": "US",
  "currency": "USD",
  "city": "Austin",
  "productCount": 120,
  "myshopifyDomain": "example-coffee.myshopify.com",
  "dataUpdatedAt": "2026-11-13"
}
```

### Pricing

Pay per event: 0.003 USD per store returned (`store-listed`). A run with no matches costs nothing.

### How the data is built

1. Domains from two open popularity lists (see below) are checked in DNS. A domain whose A record, or that of its `www.` host, points into Shopify's address range is treated as a Shopify store. Only DNS is queried at this step; the stores are not contacted.
2. For each detected store, one request to its public `/meta.json` endpoint collects name, description, country, currency, city and product count, at a low rate with an identifying User-Agent.
3. The result is stored as a compressed file bundled with the Actor. No emails or personal data are included.

### Limitations

- This is not a list of all Shopify stores. It contains only stores that appear in the popularity lists above, which is why the focus is on stores with real traffic.
- Shopify stores behind Cloudflare or another proxy resolve to different IP addresses and are not detected.
- Metadata comes from what each store publishes and can be missing or outdated.
- `keywords` match substrings, so `pet` also matches `carpet`. Use longer or more specific keywords for cleaner results.
- Some entries are regional storefronts of one brand on separate domains or subdomains (for example `us.` and `uk.`). Storefronts that share one Shopify backend are listed once.
- The data is a snapshot. Check `dataUpdatedAt`.

### Data sources and license

- [Majestic Million](https://majestic.com/reports/majestic-million), licensed CC BY 3.0. Source: Majestic.
- [Chrome UX Report](https://developer.chrome.com/docs/crux) top lists, accessed through [crux-top-lists](https://github.com/zakird/crux-top-lists), licensed CC BY-SA 4.0.

The ranking fields and the domain list in this dataset are shared under [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). If you redistribute them, credit Majestic and the Chrome UX Report and keep the same license.

### Guides

- [Turn a list of domains into qualified e-commerce leads](https://dev.to/storesignalhq/turn-a-list-of-domains-into-qualified-e-commerce-leads-emails-platform-installed-apps-1p53): a step-by-step example that combines this Actor with the other StoreSignal Actors.
- [Build a targeted list of Shopify stores by country, niche and installed apps](https://dev.to/storesignalhq/build-a-targeted-list-of-shopify-stores-by-country-niche-and-installed-apps-38mj): from a country and a keyword to a segment such as "uses Klaviyo, has no subscription app".

### Related Actors

- [storesignal/shopify-store-intelligence](https://apify.com/storesignal/shopify-store-intelligence) for detailed analysis of individual Shopify stores.
- [storesignal/website-contact-tech-finder](https://apify.com/storesignal/website-contact-tech-finder) to enrich the domains from this list with public contact details and technologies.

# Actor input Schema

## `maxResults` (type: `integer`):

Number of stores to return.

## `offset` (type: `integer`):

Number of matching stores to skip, for paging through results.

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

Two-letter ISO country codes of the store, for example US, GB, DE. Empty means any country.

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

Store currency codes, for example USD, EUR. Empty means any currency.

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

Case-insensitive substrings matched against store name, description and domain. A store matches if it contains any of the keywords.

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

Public suffixes such as com, co.uk, de. A leading dot is optional.

## `maxTrafficRank` (type: `string`):

Only stores in the Chrome UX Report popularity bucket up to this value. Stores not in the report are excluded.

## `maxMajesticRank` (type: `integer`):

Only stores with a Majestic Million rank at or below this value (1 is best).

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

Only stores with at least this many products. Stores with unknown product count are excluded.

## `maxProducts` (type: `integer`):

Only stores with at most this many products. Stores with unknown product count are excluded.

## Actor input object example

```json
{
  "maxResults": 100,
  "offset": 0,
  "countries": [
    "US"
  ]
}
```

# Actor output Schema

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

One record per matching Shopify store, in popularity order.

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

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

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

```

## MCP server setup

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

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/UTQgdNS3eOhXnEaHS/builds/EXyZNgfG4dcQZlfn4/openapi.json