# Shopify Store Analyzer: Contacts, Location & Catalog (`tacps126/shopify-store-analyzer`) Actor

Analyze Shopify stores: location, currency, product count, price range, top brands, newest product, plus e-mails, phones and socials. Filter by country, size, price, activity and e-mail; sort by size or newest product. For B2B leads. From $4 per 1,000 stores.

- **URL**: https://apify.com/tacps126/shopify-store-analyzer.md
- **Developed by:** [Tapaswai Choudhary](https://apify.com/tacps126) (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

from $3.20 / 1,000 store analyzeds

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?

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 Analyzer: Contacts, Location & Catalog

Turn a list of Shopify stores into a lead sheet. For each store you get its **name, city and country, currency, number of products and collections**, a **catalog snapshot** (price range, median price, share on sale and in stock, top brands and product types, newest product) and its **contact details** - e-mails, phone numbers and Instagram, Facebook, TikTok, LinkedIn, YouTube profiles. Export to JSON, CSV or Excel, send to Google Sheets, or call it as an API.

**Built for** agencies and SaaS teams selling to e-commerce brands, wholesalers and suppliers looking for stockists, investors and analysts sizing Shopify brands, and anyone cleaning up a store list before outreach.

### Why this analyzer

- **Straight from the store.** Location, currency and catalog size come from the store's own Shopify data, not guesses or a stale database.
- **Contacts in the same row.** The homepage and contact pages are read for e-mails, phones and social profiles, with the store's own addresses ranked first.
- **Skips what isn't Shopify.** Paste any list of websites - non-Shopify sites are skipped (and listed in the run's warnings), and you're never charged for them.
- **Fast and cheap to run.** Quick: 5 stores with contacts in about 5 seconds.
- **Handles limits for you.** Rate limits, timeouts and server hiccups are retried automatically; a restarted run continues without charging twice.

### How to use it

1. Paste store addresses into **Store websites** - `allbirds.com`, `https://www.gymshark.com`, or product and collection links (they count as their store).
2. Optionally narrow the list: stores in some **countries**, **minimum or maximum number of products**, a **typical price range**, stores **active in the last N days** (published a new product) and only stores with an **e-mail**. Untick **Find contact details** if you only need store data.
3. Optionally pick **Sort by** (most or fewest products, highest or lowest typical price, newest product, store name). The order applies to the whole list before **Max stores** cuts it, so "the 50 newest active stores with an e-mail" is one run.
4. Press **Start** and download the results from the **Output** tab.

#### Example input

```json
{
  "startUrls": ["allbirds.com", "gymshark.com", "brooklinen.com"],
  "countries": ["US", "CA"],
  "minProducts": 50,
  "requireEmail": true,
  "activeWithinDays": 60,
  "sortBy": "newestProduct",
  "includeContacts": true
}
```

### What you get

| Field | Description |
|-------|-------------|
| `storeName` / `description` | Store name and its own description |
| `domain` / `url` / `myshopifyDomain` | Website, and its `*.myshopify.com` address |
| `city` / `province` / `country` | Where the store is based (ISO country code) |
| `currency` / `shipsToCountries` | Store currency and the countries it ships to |
| `productCount` / `collectionCount` | Published products and collections |
| `shopPayInstallments` / `cardBrands` | Shop Pay Installments and accepted cards |
| `catalog` | Newest products: `priceMin`, `priceMax`, `priceMedian`, `onSalePercent`, `inStockPercent`, `topVendors`, `topProductTypes`, `newestProductAt`, `productsSampled` |
| `primaryEmail` / `emails` | Best contact e-mail and all found |
| `primaryPhone` / `phones` | Phone numbers in international format |
| `instagram` / `facebook` / `tiktok` / `linkedin` / `youtube` / `twitter` | Social profiles |
| `address` / `contactPageUrl` | Postal address and contact page, when found |
| `scrapedAt` | When the store was analyzed |

Example (shortened):

```json
{
  "storeName": "Allbirds",
  "domain": "allbirds.com",
  "city": "Beverly Hills",
  "country": "US",
  "currency": "USD",
  "productCount": 692,
  "catalog": { "priceMin": 4, "priceMax": 165, "priceMedian": 75, "onSalePercent": 55, "topProductTypes": ["Shoes", "Apparel"] },
  "primaryEmail": "help@allbirds.com",
  "phones": ["+14243638064"],
  "instagram": "https://www.instagram.com/allbirds"
}
```

### Use it as an instant API

Get the results straight in the API response with Apify's `run-sync-get-dataset-items` endpoint, ideal for apps, spreadsheets and AI agents:

```bash
curl -X POST "https://api.apify.com/v2/acts/tacps126~shopify-store-analyzer/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["allbirds.com"]}'
```

The response is the list of results. AI agents can also run it through Apify's MCP server (`https://mcp.apify.com?tools=tacps126/shopify-store-analyzer`).

### Use it in Clay

Add a **Run Apify Actor** column (Clay's Apify integration, connected to your Apify account), pick `tacps126/shopify-store-analyzer` and use this input. Type `/` inside the quotes to insert your column (store website):

```json
{"startUrls": ["/Website"]}
```

Each row gets catalog size and freshness, price range, location, currency, payment options, public contacts and social profiles. Keep auto-update off while you test.

More Clay recipes: [tacps126.github.io/clay.html](https://tacps126.github.io/clay.html).

### Pricing

Pay per store analyzed: **$4 per 1,000 stores** plus a small start fee per run. Sites that aren't Shopify stores and stores your filters drop are free. See the **Pricing** tab for exact rates, and set a maximum charge per run to cap spend.

On Apify's **free plan** each run analyzes up to 100 stores. Any paid Apify plan removes the limit.

### Related Actors

- **[Shopify Products Scraper](https://apify.com/tacps126/shopify-products)** - every product, price, variant and stock level from any store, with price-change monitoring.
- **[Website Contact Details Scraper](https://apify.com/tacps126/contact-details)** - e-mails, phones and socials for any list of websites.

### FAQ

**Where do I get a list of Shopify stores?** From your CRM, a marketplace or directory export, a Google Maps scrape, or a competitor's stockist page - paste the websites and the Actor keeps the Shopify ones.

**Why are some e-mails missing?** Some stores only offer a contact form. The Actor reports what the store publishes; it never guesses addresses.

**Is it legal?** The Actor reads information stores publish openly. You're responsible for how you use contact data - follow the laws that apply to you (e.g. GDPR, CAN-SPAM) when you reach out.

### Support

Found a problem or need a field that isn't there yet? Open an issue on the **Issues** tab with your input and what you expected - requests decide what gets built next.

# Actor input Schema

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

Shopify store addresses or bare domains (`allbirds.com`). Product or collection links count as their store. Paste a list from a spreadsheet, a Google Maps scrape or a lead list - sites that aren't Shopify stores are skipped and listed in the run's warnings.

## `includeContacts` (type: `boolean`):

Also read the store's homepage and contact pages for e-mails, phone numbers and social profiles (Instagram, Facebook, TikTok, ...). A few extra requests per store.

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

Keep only stores based in these countries: 2-letter codes (`US`, `GB`, `AU`) or names.

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

Keep only stores with at least this many published products.

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

Keep only stores with at most this many published products (small stores).

## `minPrice` (type: `integer`):

Keep only stores whose typical (median) product price is at least this, in the store's currency.

## `maxPrice` (type: `integer`):

Keep only stores whose typical (median) product price is at most this, in the store's currency.

## `activeWithinDays` (type: `integer`):

Keep only stores that published a new product within this many days.

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

Keep only stores where an e-mail address was found. Needs 'Find contact details' on.

## `sortBy` (type: `string`):

Order the stores before 'Max stores' cuts the list. Stores without the sorted value come last.

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

Maximum number of stores to return.

## `delivery` (type: `object`):

Webhook: {"webhookUrl": "https://...", "format": "json" | "slack" | "discord", "onlyWhenResults": true, "includeItems": 10}. Google Sheets: {"spreadsheetId": "<id from the sheet URL>", "sheetName": "Sheet1"} plus the service account key below; share the sheet with the service account's e-mail first. Leave empty to only save results in the dataset.

## `googleServiceAccountJson` (type: `string`):

Only for Google Sheets delivery: paste the service account's JSON key. Stored encrypted; the account sees only sheets you share with it.

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

Not needed for most stores. Turn on for stores that limit repeated visits or for very frequent runs.

## `tenantId` (type: `string`):

Optional label used to keep separate histories for different clients or teams.

## `debug` (type: `boolean`):

Save extra diagnostics with the run (for support requests).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.allbirds.com",
    "https://www.gymshark.com"
  ],
  "includeContacts": true,
  "requireEmail": false,
  "sortBy": "default",
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "debug": false
}
```

# Actor output Schema

## `products` (type: `string`):

Every product found, in one consistent format.

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

Counts, warnings, and whether the run stopped early (e.g. at your spending limit).

# 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": [
        "https://www.allbirds.com",
        "https://www.gymshark.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tacps126/shopify-store-analyzer").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": [
        "https://www.allbirds.com",
        "https://www.gymshark.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tacps126/shopify-store-analyzer").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 '{
  "startUrls": [
    "https://www.allbirds.com",
    "https://www.gymshark.com"
  ]
}' |
apify call tacps126/shopify-store-analyzer --silent --output-dataset

```

## MCP server setup

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

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/UqoyKvfTAfXBcJoO3/builds/nwy9ZpsF8ADzlgzxg/openapi.json