# Shopify Store Intelligence (`pintostudio/shopify-store-intelligence`) Actor

Full competitive-intelligence report for any Shopify store: detected apps & tech stack, social profiles, complete store info, an estimated monthly revenue & traffic figure with a confidence score, and an optional product sample - all in one call, no login required.

- **URL**: https://apify.com/pintostudio/shopify-store-intelligence.md
- **Developed by:** [Pinto Studio](https://apify.com/pintostudio) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 results

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?

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 Intelligence

**Full competitive-intelligence report for any Shopify store — in one API call.**

Feed in one or more store domains and get back the detected apps & tech stack, every social
media profile, complete public store info (theme, currency, shop ID, contact emails, shipping
countries...), an estimated monthly & annual revenue and traffic figure with a confidence score,
and an optional sample of the product catalogue. No login, no scraping setup, no stitching
together three different tools — just domains in, a structured JSON report out.

*Not affiliated with or endorsed by Shopify Inc. Revenue and traffic figures are directional
estimates, not verified financial data — see the Revenue estimates section below.*

***

### Why this Actor

Most "Shopify store checker" or "Shopify analyzer" tools give you either a product scrape or a
revenue guess — rarely both, and almost never with the app stack, social profiles and shop
contacts alongside. This Actor pulls the full picture from one backend in a single pass, so a
competitor teardown, prospecting list, or market-research report doesn't need three different
tools stitched together by hand.

Typical uses:

- **Competitive intelligence** — see exactly which apps (email/SMS, reviews, subscriptions,
  loyalty, upsell) a competitor's store runs, and how their tech stack compares to yours.
- **Sales & agency prospecting** — build a qualified lead list of Shopify stores with an
  estimated revenue band, so outreach can be prioritized by store size instead of guessing.
- **Market & category research** — analyze a batch of stores in a niche to spot which apps and
  platforms are winning, and benchmark estimated revenue across a category.
- **Investor / M\&A due diligence** — get a fast, independent directional read on a store's
  traffic and revenue trajectory (with the confidence label and the underlying assumptions
  exposed) before deeper diligence.
- **Influencer & partnership vetting** — check the legitimacy, scale and tech maturity of a
  Shopify brand before proposing a partnership.

### What you get for each store

| Data point | Input toggle | Always attempted? |
|---|---|---|
| Shopify platform detection (confidence score, signals, myshopify domain) | — | Yes, every domain |
| Detected apps & tech stack | `includeApps` | Only if enabled |
| Social media profiles (11 networks) | `includeSocials` | Only if enabled |
| Full public store info (theme, currency, shop ID, emails, shipping countries...) | `includeInfo` | Only if enabled |
| Published store pages | `includePages` | Only if enabled |
| Estimated monthly & annual revenue and traffic, with confidence score | `includeRevenue` | Only if enabled |
| Product catalogue sample | `includeProducts` | Only if enabled |

A store that fails to analyze still produces a row (`{ domain, error }`) instead of failing the
whole run, so a batch of 50 domains never gets derailed by one bad URL — you always get output
for every input domain.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `domains` | array of strings | — (required) | One or more store domains or URLs, e.g. `"allbirds.com"`. Up to 10 per run. |
| `includeApps` | boolean | `true` | Detect installed apps and theme/tech stack (e.g. Klaviyo, Recharge, Yotpo). |
| `includeSocials` | boolean | `true` | Extract social profile links (Instagram, Facebook, TikTok, X/Twitter, YouTube, Pinterest, LinkedIn, Snapchat, Threads, WhatsApp, Telegram). |
| `includeInfo` | boolean | `true` | Extract full public store information (theme, currency, shop ID, contact emails, shipping countries, payment brands, etc.). |
| `includePages` | boolean | `false` | Include the store's published pages. |
| `includeRevenue` | boolean | `true` | Include an estimated monthly & annual revenue and traffic figure, with a confidence level and plain-language summary. |
| `includeProducts` | boolean | `false` | Include a sample of the store's products (title, price, handle). |
| `maxProductSample` | integer | `20` | Max products to include per store when `includeProducts` is on (1–250). Ignored otherwise. |
| `country` | string | — | Optional ISO 2-letter country code to sharpen the revenue estimate for stores that serve a specific market. |
| `concurrency` | integer | `4` | How many stores to analyze in parallel (1–10). Higher is faster but heavier on the backend. |

Minimal input:

```json
{ "domains": ["allbirds.com"] }
```

Batch input analyzing several stores in parallel, revenue-only (fast & cheap):

```json
{
  "domains": ["allbirds.com", "gymshark.com", "yourcompetitor.com"],
  "includeApps": false,
  "includeSocials": false,
  "includeInfo": false,
  "includeRevenue": true,
  "concurrency": 4
}
```

### Output example

Each dataset row is a JSON object shaped like this (abbreviated — real `info` and `revenue`
objects are considerably larger; a real run against `allbirds.com` returns 6 top-level info
fields, 14 platform-detection fields, 22 app fields and an 11-section revenue model):

```json
{
  "domain": "allbirds.com",
  "analyzedAt": "2026-09-13T07:12:48.979Z",
  "apps": [
    {
      "name": "Attentive: AI-led Email & SMS",
      "icon_url": "https://cdn.shopify.com/app-store/listing_images/.../icon.png",
      "shopifyUrl": "https://apps.shopify.com/attentive",
      "url": "https://www.attentive.com"
    }
  ],
  "platform": {
    "shopifyPublicDomain": "weareallbirds.myshopify.com",
    "confidence": 99.9,
    "isShopify": true,
    "signals": ["myshopify_domain", "url_path_patterns", "shopify_reference_volume"],
    "url": "allbirds.com"
  },
  "socials": {
    "twitter": ["https://twitter.com/allbirds"],
    "instagram": ["https://instagram.com/allbirds"],
    "facebook": ["https://www.facebook.com/weareallbirds"],
    "youtube": ["https://www.youtube.com/channel/UCnGErLCau5qNJ0Xwe6uEyTw"],
    "tiktok": ["https://www.tiktok.com/@weareallbirds"],
    "pinterest": ["https://www.pinterest.com/weareallbirds"]
  },
  "info": {
    "title": "The World's Most Comfortable Shoes",
    "siteName": "Allbirds",
    "storeCurrency": "USD",
    "shopId": "11044168",
    "availableProducts": 294,
    "emails": ["help@allbirds.com"],
    "shipstoCountries": ["US"]
  },
  "revenue": {
    "monthly": { "orders": 34828, "revenue": 6220584.43, "revenueCompact": "$6.22M" },
    "annual": { "revenue": 78575803.38, "revenueCompact": "$78.58M" },
    "confidence": { "score": 0.62, "label": "medium" },
    "summary": "allbirds.com — apparel_contemporary. Human sessions: 651,096/month..."
  }
}
```

A store that isn't actually a live Shopify site still returns a row with `platform.isShopify:
false` rather than erroring the run. A store your account couldn't reach at all returns
`{ "domain": "...", "error": "..." }`.

### How the revenue estimate works

The `revenue` object is a **directional estimate**, built from a traffic panel, category
benchmarks and the store's own live catalogue pricing — it is *not* pulled from Shopify's private
sales data, which no third-party tool can access. Every estimate ships with:

- A **low–high range**, not just a single number — always read the range, not the point figure.
- A **confidence score and label** (`low` / `medium` / `high`) reflecting how much traffic
  history was available and how volatile it was.
- The **assumptions and factors** used (conversion-rate model, average order value, brand
  strength, returning-visitor share, channel mix) so you can sanity-check the output instead of
  trusting a black box.
- A **plain-language summary** paragraph plus a country and traffic-source breakdown.

Use it to rank and prioritize stores by size, not as a substitute for verified financial data.

### Pricing (pay-per-event)

This Actor is priced per event via `Actor.charge()`. The USD amount for each event is configured
in the Apify Console (Publication → Monetization → Pay-per-event), not in the code — the table
below shows suggested starting prices:

| Event | Fires | Suggested price |
|---|---|---|
| `actor-start` | Once per run | $0.02 |
| `store-analyzed` | Per store successfully analyzed (apps/socials/info bundle) | $0.10 |
| `revenue-estimated` | Per store where a revenue estimate was returned | $0.05 |
| `products-included` | Per store where a product sample was returned | $0.03 |

A full report (`store-analyzed` + `revenue-estimated` + `products-included`) lands around
**$0.18** per store — priced for the depth of a multi-part intelligence report rather than a bare
list, and in line with comparable "store analyzer" Actors in this category. Tune against your own
usage pattern before relying on it at scale.

### Getting started

1. Open the **Input** tab and enter one or more store domains (e.g. `allbirds.com`).
2. Toggle on the sections you need — apps, socials, store info, pages, revenue, products.
3. Click **Start**. A typical single-store run finishes in a few seconds.
4. Open the **Dataset** tab (or the **Output** tab) to view or export the results as JSON, CSV,
   Excel, or via the API.

### Run programmatically via the API

```bash
curl "https://api.apify.com/v2/acts/pintostudio~shopify-store-intelligence/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "domains": ["allbirds.com"] }'
```

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('pintostudio/shopify-store-intelligence').call({
  domains: ['allbirds.com', 'gymshark.com'],
  includeRevenue: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("pintostudio/shopify-store-intelligence").call(run_input={
    "domains": ["allbirds.com", "gymshark.com"],
    "includeRevenue": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

This Actor also ships a Live-view/OpenAPI web-server schema, so it can be called as a
standalone REST API — see the **API** tab on this Actor's page for the full request/response
reference and a ready-to-run OpenAPI spec.

### Frequently asked questions

**Does this need a Shopify login or API access token from the target store?**
No. Everything is derived from what's publicly visible about the store — no login, no
partnership, no API key for the store you're analyzing.

**How accurate is the revenue estimate?**
It's a directional, panel- and catalogue-based model, always shipped with a range and a
confidence label — treat it as a sizing signal, not verified sales data.

**What happens if a domain isn't a Shopify store?**
You still get a row back, with `platform.isShopify: false` — the run doesn't fail.

**Can I analyze more than 10 domains in one run?**
Each run is capped at 10 domains to keep individual runs fast and predictable; queue additional
runs, or Tasks, for larger batches.

**Can I use this for outreach or lead scoring?**
Yes — the estimated revenue band and detected app stack are commonly used to prioritize and
segment a list of Shopify prospects before sales or partnership outreach.

### Notes & limitations

- Revenue and traffic figures are **estimates**, not verified financials — always labeled with a
  confidence level, matching the underlying model's output.
- Detected apps, socials and store info reflect what's publicly discoverable at the time of the
  run; a store that changes its app stack or socials will show updated results on the next run.
- A domain that isn't actually a live Shopify store still returns a row with
  `platform.isShopify: false` rather than erroring the run.
- Up to 10 unique domains are processed per run; duplicate domains in your input are
  automatically de-duplicated.

***

### Shopify store analyzer, competitor research & revenue estimator — in one Actor

Looking for a **Shopify store checker**, **Shopify competitor analysis tool**, **Shopify revenue
estimator**, or a way to find out **what apps a Shopify store uses**? This Actor is built to
answer exactly those questions in a single run. It works as a **Shopify spy tool** for
e-commerce research, a **Shopify sales intelligence** and **prospecting tool** for agencies and
SaaS sales teams, and a **Shopify store traffic estimator** for market sizing — covering
competitive intelligence, tech-stack detection, social-media audits, and estimated monthly and
annual revenue for any Shopify-powered online store. Common searches this Actor answers: "how to
check what apps a Shopify store is using", "estimate Shopify store revenue", "find Shopify store
social media accounts", "Shopify store traffic checker", "Shopify competitor research tool", and
"bulk Shopify store analyzer API". Whether you need a one-off lookup or a scheduled Task that
re-analyzes a watchlist of competitor stores every week, this Actor turns any Shopify domain into
a structured, exportable competitive-intelligence report — ready for Google Sheets, Airtable, a
CRM, or your own data warehouse via the Apify API, JSON, CSV or Excel export.

# Actor input Schema

## `domains` (type: `array`):

One or more Shopify store domains or URLs, e.g. "allbirds.com".

## `includeApps` (type: `boolean`):

Detect installed apps and the theme/tech stack for each store (e.g. Klaviyo, Recharge, Yotpo).

## `includeSocials` (type: `boolean`):

Extract social media profile links (Instagram, Facebook, TikTok, etc.) for each store.

## `includeInfo` (type: `boolean`):

Extract publicly store information for each store.

## `includePages` (type: `boolean`):

Include the store's published pages.

## `includeRevenue` (type: `boolean`):

Include an estimated monthly revenue and traffic figure for each store, with a confidence level and a plain-language summary.

## `includeProducts` (type: `boolean`):

Include a sample of the store's products (title, price, handle) — see Max products to include per store.

## `maxProductSample` (type: `integer`):

Maximum number of products to pull per store when "Include a product catalogue sample" is on. Ignored otherwise.

## `country` (type: `string`):

Optional. Sharpens the revenue estimate for stores serving a specific country.

## `concurrency` (type: `integer`):

How many stores to analyze in parallel. Higher is faster but heavier on the backend.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com"
  ],
  "includeApps": true,
  "includeSocials": true,
  "includeInfo": true,
  "includePages": false,
  "includeRevenue": true,
  "includeProducts": false,
  "maxProductSample": 20,
  "concurrency": 4
}
```

# Actor output Schema

## `storeReports` (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 = {
    "domains": [
        "allbirds.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pintostudio/shopify-store-intelligence").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 = { "domains": ["allbirds.com"] }

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

```

## MCP server setup

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

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/hrZBvavR15aKLbGw3/builds/wm5jvakFBREVzx9Q2/openapi.json