# Shopify Store Intel — Products, Prices & Apps (`ryanclinton/shopify-store-intelligence`) Actor

Analyze any Shopify store and extract its complete product catalog, pricing data, installed apps, theme information, and competitive metrics — all without needing a Shopify API key.

- **URL**: https://apify.com/ryanclinton/shopify-store-intelligence.md
- **Developed by:** [Ryan Clinton](https://apify.com/ryanclinton) (community)
- **Categories:** E-commerce, AI
- **Features:** Limited permissions
- **Stats:** 17 total users, 2 monthly users, 98.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $48.00 / 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 Intelligence

Analyze any Shopify-powered online store and extract its complete product catalog, pricing data, installed apps, theme information, and competitive metrics -- all without needing a Shopify API key. Feed it one URL or a hundred. For each store you get back product details with pricing, on-sale and stock status, the Shopify theme in use, the store currency, a list of detected third-party apps (Klaviyo, Yotpo, Afterpay, and 35+ others), plus aggregate statistics like average price, price range, vendor breakdown, product types, and top tags.

This actor uses Shopify's public `/products.json` endpoint combined with HTML analysis of the store's homepage. No authentication or store owner permission is required -- it collects the same information any visitor can see in their browser.

### Why use Shopify Store Intelligence on Apify?

Manually reviewing a competitor's Shopify store is tedious. You have to browse through products page by page, view source to find their theme and installed apps, and there is no built-in way to export the data or track changes over time. The alternative -- building your own scraper -- requires handling URL normalization, pagination, proxy rotation, Shopify detection, and app fingerprinting.

This actor handles all of that. Running on Apify's cloud:

- **No API key needed** -- Works entirely through publicly accessible Shopify endpoints.
- **Batch analysis** -- Process hundreds of stores in a single run with automatic deduplication by domain.
- **App detection** -- Identifies 40+ third-party Shopify apps from the HTML source, including reviews, email marketing, buy-now-pay-later, analytics, and page builders.
- **Pricing analytics** -- Calculates min/max/average prices, sale counts, and out-of-stock percentages across the entire catalog.
- **Scheduled monitoring** -- Track competitor stores weekly or monthly with Apify's scheduler.
- **Proxy support** -- Built-in Apify proxy integration for reliable access at scale.

### Key features

- **Shopify detection** -- Automatically confirms whether each URL is actually a Shopify store before attempting data extraction.
- **Full product catalog extraction** -- Fetches every product via the public `/products.json` endpoint with pagination support for stores with thousands of SKUs.
- **Pricing analytics** -- Calculates min/max price range, average price, sale counts, and compare-at-price data across the entire catalog.
- **Theme identification** -- Detects the active Shopify theme name and ID from the page source.
- **App detection (40+ apps)** -- Identifies installed third-party apps including review platforms, email/SMS marketing, buy-now-pay-later, page builders, analytics, and customer support tools.
- **Stock monitoring** -- Flags out-of-stock products and tracks available inventory status per variant.
- **Vendor and category breakdown** -- Extracts unique vendors, product types, and the top 20 most-used tags.
- **Bulk analysis** -- Process hundreds of Shopify stores in a single run with deduplication.
- **No API key required** -- Works entirely through publicly accessible Shopify endpoints.

### Use cases

**Competitor analysis for e-commerce brands** -- A DTC skincare brand monitors 15 competitor Shopify stores weekly. They track `productCount`, `averagePrice`, and `onSaleCount` over time to spot pricing trends and promotional patterns. When a competitor adds Afterpay, they know it is time to add BNPL to their own store.

**Dropshipping niche research** -- A dropshipper evaluates 50 stores in the pet accessories niche by running a single batch. They compare average prices, vendor diversity (how many suppliers each store uses), and catalog sizes to identify profitable niches with low competition.

**SaaS sales prospecting** -- A Shopify app company targets stores that are missing their email marketing tool. They run the actor on 200 stores in a vertical, filter for those without Klaviyo or Omnisend in `detectedApps`, and add them to their outreach pipeline.

**Market research for investors** -- A venture capital analyst evaluates a portfolio company's competitive landscape by analyzing 30 DTC brands in the same category. They compare catalog sizes, pricing strategies, and tech stack maturity.

**Agency client audits** -- A Shopify development agency runs the actor on a prospect's store before the sales call. They identify optimization opportunities in the theme, missing apps (e.g., no review platform, no analytics beyond basic GA), and pricing strategy.

**Brand protection** -- A brand owner monitors unauthorized resellers by scanning Shopify stores selling their products. They filter the `vendors` field for their brand name across hundreds of stores.

### How to use Shopify Store Intelligence

1. **Provide store URLs** -- Enter one or more Shopify store URLs in the input. The actor accepts any format: `allbirds.com`, `https://www.gymshark.com`, or `https://kith.com/`.
2. **Set product limits** -- Choose how many products to fetch per store (default 250, max 10,000). Set lower for quick audits or higher for complete catalog dumps.
3. **Choose output detail** -- Enable "Include full product list" for individual product data, or disable it to get only store-level summary statistics.
4. **Run and export** -- Start the actor and download results as JSON, CSV, or Excel. Each store produces one result row with all metrics and an embedded product array.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `urls` | String\[] | Yes | - | List of Shopify store URLs to analyze. Accepts any format. |
| `maxProducts` | Integer | No | 250 | Maximum number of products to fetch per store (1-10,000). |
| `includeProducts` | Boolean | No | true | Include the full product list in output, or only store-level stats. |
| `proxyConfiguration` | Object | No | - | Proxy settings for HTTP requests. |

#### Input examples

**Single store deep dive:**

```json
{
    "urls": ["https://allbirds.com"],
    "maxProducts": 5000,
    "includeProducts": true
}
```

**Batch competitor scan (summary only):**

```json
{
    "urls": [
        "allbirds.com",
        "gymshark.com",
        "kith.com",
        "cotopaxi.com",
        "bombas.com",
        "brooklinen.com"
    ],
    "maxProducts": 250,
    "includeProducts": false
}
```

**Full catalog with proxy:**

```json
{
    "urls": ["https://fashionnova.com"],
    "maxProducts": 10000,
    "includeProducts": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
```

#### Input tips

- **Start without the product list** -- Set `includeProducts` to false for initial screening of many stores. Once you identify interesting targets, re-run with products enabled.
- **Use lower product limits for speed** -- If you only need pricing trends and app detection, fetching 50-100 products is usually enough for representative statistics.
- **Batch related stores together** -- The actor deduplicates URLs by domain, so you can paste in a large list without worrying about duplicates wasting compute time.
- **URL format is flexible** -- You can mix formats freely: `allbirds.com`, `www.allbirds.com`, `https://allbirds.com` all resolve to the same store.

### Output example

Each store produces a single result object:

```json
{
    "url": "https://allbirds.com",
    "domain": "allbirds.com",
    "isShopify": true,
    "storeName": "Allbirds",
    "theme": "Custom Theme",
    "themeId": 139483726,
    "currency": "USD",
    "productCount": 87,
    "totalProductsFetched": 87,
    "priceRange": {
        "min": 18.0,
        "max": 220.0
    },
    "averagePrice": 104.52,
    "onSaleCount": 12,
    "outOfStockCount": 4,
    "vendors": ["Allbirds"],
    "productTypes": ["Shoes", "Socks", "Apparel", "Accessories"],
    "topTags": [
        { "tag": "mens", "count": 42 },
        { "tag": "womens", "count": 39 },
        { "tag": "shoes", "count": 34 },
        { "tag": "new-arrivals", "count": 15 },
        { "tag": "sale", "count": 12 }
    ],
    "detectedApps": [
        "Afterpay",
        "Google Analytics",
        "Google Tag Manager",
        "Klaviyo",
        "Meta Pixel",
        "Segment",
        "TikTok Pixel",
        "Yotpo Reviews"
    ],
    "products": [
        {
            "title": "Men's Tree Runners",
            "handle": "mens-tree-runners",
            "vendor": "Allbirds",
            "type": "Shoes",
            "price": 98.0,
            "compareAtPrice": null,
            "onSale": false,
            "variants": 12,
            "inStock": true,
            "createdAt": "2023-06-15T10:30:00-04:00",
            "imageUrl": "https://cdn.shopify.com/s/files/1/0070/1922/products/mens-tree-runners.jpg",
            "url": "https://allbirds.com/products/mens-tree-runners",
            "tags": ["mens", "shoes", "tree", "runners", "bestseller"]
        }
    ],
    "analyzedAt": "2025-01-15T14:22:33.000Z"
}
```

#### Output fields -- store level

| Field | Type | Description |
|-------|------|-------------|
| `url` | String | The URL as provided in the input |
| `domain` | String | Normalized domain name (e.g., `allbirds.com`) |
| `isShopify` | Boolean | Whether the site was confirmed as a Shopify store |
| `storeName` | String/null | Store name extracted from Shopify metadata or meta tags |
| `theme` | String/null | Active Shopify theme name |
| `themeId` | Number/null | Shopify theme ID |
| `currency` | String/null | Store currency code (e.g., `USD`, `GBP`, `EUR`) |
| `productCount` | Number | Total number of products found |
| `totalProductsFetched` | Number | Number of products actually fetched (may be less than total if capped by `maxProducts`) |
| `priceRange` | Object/null | `{ min, max }` price range across all products |
| `averagePrice` | Number/null | Average product price (rounded to 2 decimal places) |
| `onSaleCount` | Number | Number of products with a compare-at price higher than the current price |
| `outOfStockCount` | Number | Number of products with no available variants |
| `vendors` | String\[] | Sorted list of unique vendor/brand names |
| `productTypes` | String\[] | Sorted list of unique product type categories |
| `topTags` | Object\[] | Top 20 most-used tags with counts: `[{ tag, count }]` |
| `detectedApps` | String\[] | Sorted list of detected third-party apps and services |
| `products` | Object\[] | Full product list (empty if `includeProducts` is false) |
| `analyzedAt` | String | ISO timestamp of when the analysis was performed |

#### Output fields -- product level

| Field | Type | Description |
|-------|------|-------------|
| `title` | String | Product title |
| `handle` | String | URL-friendly product handle |
| `vendor` | String | Vendor/brand name |
| `type` | String | Product type category |
| `price` | Number | Price of the first variant (parsed to number) |
| `compareAtPrice` | Number/null | Original price before discount (null if not on sale) |
| `onSale` | Boolean | True if compare-at price exists and is higher than current price |
| `variants` | Number | Number of variants (sizes, colors, etc.) |
| `inStock` | Boolean | True if at least one variant is available |
| `createdAt` | String | ISO timestamp when the product was created |
| `imageUrl` | String/null | URL of the first product image |
| `url` | String | Full URL to the product page |
| `tags` | String\[] | Product tags assigned in Shopify admin |

### How much does it cost?

Shopify Store Intelligence uses **pay-per-event pricing** -- you pay **$0.50 per store analyzed**. Platform usage costs are included in the price.

| Scenario | Stores | Cost per store | Total cost |
|----------|--------|----------------|------------|
| Quick audit | 1 | $0.50 | $0.50 |
| Competitor batch | 10 | $0.50 | $5.00 |
| Niche research | 50 | $0.50 | $25.00 |
| Large-scale research | 100 | $0.50 | $50.00 |

You can set a **maximum spending limit** per run to control costs. The actor will stop analyzing stores once your budget is reached, so you never pay more than you expect.

**Apify Free Tier:** New Apify accounts receive $5 of free platform credits each month, enough for 10 store analyses.

### Analyze Shopify stores using the API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "urls": ["allbirds.com", "gymshark.com", "kith.com"],
    "maxProducts": 250,
    "includeProducts": False,
}

run = client.actor("ryanclinton/shopify-store-intelligence").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['domain']}: {item['productCount']} products, "
          f"avg ${item['averagePrice']}, apps: {', '.join(item['detectedApps'])}")
```

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_APIFY_API_TOKEN" });

const run = await client.actor("ryanclinton/shopify-store-intelligence").call({
    urls: ["allbirds.com", "gymshark.com", "kith.com"],
    maxProducts: 250,
    includeProducts: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.log(`${item.domain}: ${item.productCount} products, avg $${item.averagePrice}`);
    console.log(`  Apps: ${item.detectedApps.join(", ")}`);
});
```

#### cURL

```bash
## Start the actor
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~shopify-store-intelligence/runs?token=YOUR_APIFY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["allbirds.com", "gymshark.com"],
    "maxProducts": 250,
    "includeProducts": false
  }'

## Retrieve results (use the defaultDatasetId from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_API_TOKEN&format=json"
```

### How it works

1. **URL normalization** -- Each input URL is cleaned and normalized. The actor strips paths, adds `https://` if missing, and deduplicates by domain name so the same store is never analyzed twice.

2. **Shopify detection** -- The actor fetches each store's homepage HTML using CheerioCrawler and checks for Shopify signatures: references to `Shopify.` JavaScript objects, `cdn.shopify.com` asset URLs, or `myshopify.com` domains. Non-Shopify sites are flagged with `isShopify: false` and returned with empty data.

3. **Theme and metadata extraction** -- For confirmed Shopify stores, the actor parses the homepage HTML to extract the `Shopify.theme` JavaScript object (theme name and ID), `Shopify.currency` (active currency code), and the store name from `Shopify.shop` or OpenGraph meta tags.

4. **App detection** -- The full HTML source is scanned against 40+ regex patterns that match known third-party app script URLs and identifiers. For example, `klaviyo.com` in the source indicates Klaviyo is installed, `afterpay.com` indicates Afterpay, and so on. Results are deduplicated and sorted alphabetically.

5. **Product catalog fetching** -- The actor calls the public `/products.json` endpoint with pagination (250 products per page). It pages through until all products are fetched or the `maxProducts` limit is reached. Products that return a 404 or 403 mean the store has disabled the public endpoint.

6. **Analytics computation** -- For each store, the actor computes aggregate statistics: price range (min/max), average price (from first-variant prices), on-sale count (products where `compare_at_price > price`), out-of-stock count (products with no available variants), unique vendors, unique product types, and the top 20 most-used tags.

7. **Output** -- One result object per store is pushed to the Apify dataset with all store-level metrics and optionally the full product array.

### Detected apps reference

The actor recognizes 40+ Shopify apps and third-party services by scanning the store's HTML source:

| Category | Apps Detected |
|----------|---------------|
| Reviews | Yotpo, Judge.me, Loox, Stamped.io, Okendo |
| Email / SMS | Klaviyo, Omnisend, Mailchimp, Attentive, Postscript |
| Pop-ups & Conversion | Privy, Justuno |
| Loyalty & Referrals | Smile.io, ReferralCandy |
| Subscriptions | ReCharge |
| Buy Now Pay Later | Afterpay, Klarna, Sezzle |
| Page Builders | PageFly, Shogun, GemPages, Zipify Pages |
| Analytics | Google Analytics, Google Tag Manager, Hotjar, Segment, Lucky Orange |
| Advertising | Meta Pixel, TikTok Pixel, Pinterest Tag, LinkedIn Insight Tag |
| Customer Support | Zendesk, Gorgias, Intercom, Tidio |
| Dropshipping | Oberlo, DSers |
| Other | Bold Commerce, Back in Stock, Wishlist, Shopify App Bridge |

Detection is based on script URL patterns in the HTML source. Apps that load entirely via Shopify's app proxy or backend-only apps may not be detected.

### Tips for best results

- **Start without the product list** -- Set `includeProducts` to false for initial screening of many stores. Once you identify interesting targets, re-run with products enabled for the deep dive.
- **Use lower product limits for speed** -- If you only need pricing trends and app detection, fetching 50-100 products is usually enough to get representative statistics without waiting for full pagination.
- **Batch related stores together** -- The actor deduplicates URLs by domain, so you can paste in a large list without worrying about duplicates wasting compute time.
- **Check `isShopify` first** -- When processing mixed URL lists, filter results by `isShopify: true` to separate confirmed Shopify stores from non-Shopify sites.
- **Schedule recurring runs** -- Use Apify Schedules to monitor competitor stores weekly. Compare `productCount`, `averagePrice`, and `onSaleCount` over time to spot trends.
- **Use proxy for large batches** -- Enable Apify proxy for runs with 50+ stores to avoid rate limiting or IP blocks.

### Combine with other actors

- **[Website Tech Stack Detector](https://apify.com/ryanclinton/website-tech-stack-detector)** -- Broader technology detection beyond Shopify, covering CMS platforms, frameworks, CDNs, and analytics tools for any website.
- **[Website Contact Scraper](https://apify.com/ryanclinton/website-contact-scraper)** -- Extract emails, phone numbers, and social media links from the stores you analyze to build a contact list for outreach.
- **[E-Commerce Price Monitor](https://apify.com/ryanclinton/ecommerce-price-monitor)** -- Track product prices over time across e-commerce sites with automated change detection and alerts.
- **[Brand Protection Monitor](https://apify.com/ryanclinton/brand-protection-monitor)** -- Monitor the web for unauthorized use of your brand name, trademarks, and product listings.
- **[WHOIS Domain Lookup](https://apify.com/ryanclinton/whois-domain-lookup)** -- Get domain registration details, ownership info, and expiration dates for the stores you analyze.
- **[SaaS Competitive Intelligence](https://apify.com/ryanclinton/saas-competitive-intel)** -- Deeper competitive analysis combining multiple data sources for market research beyond Shopify.
- **[Website Content to Markdown](https://apify.com/ryanclinton/website-content-to-markdown)** -- Extract the full page content of any store's landing pages for content analysis and comparison.

### Limitations

- **Public endpoint only** -- The actor relies on Shopify's `/products.json` endpoint. Some stores disable this endpoint, in which case you will get theme and app data from HTML analysis but zero products.
- **First-variant pricing** -- Product prices are extracted from the first variant only. If a product has variants with different prices (e.g., sizes), the price shown is for the first/default variant.
- **App detection is pattern-based** -- Apps are detected by scanning HTML source for known script URL patterns. Apps that load entirely via Shopify's backend, app proxy, or server-side injection may not be detected. The list covers 40+ popular apps but is not exhaustive.
- **No historical data** -- Each run captures a point-in-time snapshot. To track changes over time, schedule recurring runs and compare datasets.
- **Non-Shopify sites** -- The actor only extracts product data from Shopify stores. Non-Shopify sites are returned with `isShopify: false` and empty product data.
- **Rate limiting** -- Fetching very large catalogs (5,000+ products) from a single store may encounter Shopify's rate limiting. The actor handles this gracefully but some products may be missed.
- **Currency is store-level** -- The currency field reflects the store's primary currency. Multi-currency stores will show the default currency only.

### Responsible use

- **Public data** -- This actor accesses only publicly available data through Shopify's standard `/products.json` endpoint and the store's homepage HTML. It collects the same information any customer can see by visiting the store.
- **Terms of service** -- Always review and comply with each store's terms of service before large-scale data collection. Some stores may prohibit automated access.
- **Rate limiting** -- Keep `maxProducts` and batch sizes reasonable. Avoid scheduling runs more frequently than necessary for your analysis needs.
- **Contact data** -- This actor does not extract personal contact information. Store names and vendor names are business identifiers, not personal data.
- **Competitive intelligence** -- Use the data for legitimate business analysis, market research, and competitive benchmarking purposes.

### FAQ

**Is it legal to scrape Shopify stores?**
This actor accesses only publicly available data through Shopify's standard `/products.json` endpoint, which is accessible to any web browser. It collects the same information any customer can see by visiting the store. Always review and comply with each store's terms of service before large-scale collection.

**Do I need a Shopify API key?**
No. The actor uses Shopify's public product endpoint that requires no authentication. It works on any Shopify store that has not explicitly blocked this endpoint.

**What if a store blocks `/products.json`?**
Some stores disable the public products endpoint. In that case the actor will still detect the theme, currency, store name, and installed apps from the homepage HTML -- you will just get zero products.

**How many apps can it detect?**
The actor recognizes 40+ popular Shopify apps and third-party services. See the detected apps reference table above for the full list by category.

**Can I analyze non-Shopify stores?**
The actor will flag non-Shopify stores with `isShopify: false` in the output. It does not extract product data from other platforms like WooCommerce, Magento, or BigCommerce.

**How accurate is the pricing data?**
Prices come directly from Shopify's product API and reflect the current listed price of the first variant. Compare-at prices are included when available, letting you identify which products are on sale and by how much.

**What is the maximum number of stores I can analyze?**
There is no hard limit. The actor processes stores sequentially. For very large batches (500+ stores), consider breaking them into smaller runs to manage timeout and memory.

**Can I get results in CSV or Excel format?**
Yes. After the actor completes, click "Export" on the dataset page and choose CSV, Excel, JSON, or other formats. The Apify API also supports `format=csv` and `format=xlsx` query parameters. Note that the nested `products` array will be flattened in tabular formats.

### Integrations

- **Google Sheets** -- Export results directly to Google Sheets using the Apify integration. Ideal for maintaining a live competitor tracking spreadsheet.
- **Slack / Email** -- Get notifications when a run completes with summary statistics.
- **Webhooks** -- Push results to your CRM, data warehouse, or custom pipeline.
- **Zapier / Make** -- Connect to thousands of apps for custom automation workflows.
- **REST API** -- Call the actor programmatically via the Apify API. Start runs, poll for status, and download datasets in JSON, CSV, XML, or Excel format.
- **Python & JavaScript SDKs** -- Use the official Apify SDKs to integrate store intelligence into your own applications and data pipelines.

### Support

Found a bug or have a feature request? Open an issue in the [Issues tab](https://console.apify.com/actors) on this actor's page. For custom e-commerce intelligence solutions, reach out through the Apify platform.

# Actor input Schema

## `urls` (type: `array`):

List of Shopify store URLs to analyze (e.g., https://allbirds.com, https://gymshark.com).

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

Maximum products to fetch per store. Set higher for complete catalog analysis.

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

Include the full product list in output. Disable to only get store-level summary stats.

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

Proxy settings for requests.

## Actor input object example

```json
{
  "urls": [
    "https://allbirds.com",
    "https://gymshark.com"
  ],
  "maxProducts": 250,
  "includeProducts": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Store summary with domain, theme, currency, product count, and pricing metrics.

## `allItems` (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 = {
    "urls": [
        "https://allbirds.com",
        "https://gymshark.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ryanclinton/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 = {
    "urls": [
        "https://allbirds.com",
        "https://gymshark.com",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ryanclinton/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/eiHLUkf3SgN0tv0JL/builds/nQfFRWMxHC7wLZbQp/openapi.json