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

Analyze Shopify stores: extract products, prices, collections, themes, and apps. Competitive e-commerce intelligence.

- **URL**: https://apify.com/viralanalyzer/shopify-store-intelligence.md
- **Developed by:** [viralanalyzer](https://apify.com/viralanalyzer) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 4.74 out of 5 stars

## Pricing

from $26.25 / 1,000 product scrapeds

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 — Products, Prices, Inventory & Competitive Analysis

> 🔗 [View on Apify Store](https://apify.com/viralanalyzer/shopify-store-intelligence) | 🇺🇸 English | [🇧🇷 Português](#português)

Extract **product catalogs, pricing, variants, inventory status, and collections** from any Shopify store. Uses Shopify's public JSON API — ultra-fast, pure HTTP, no browser needed.

### ✨ Features

- **Multi-store analysis** — Analyze up to 50 Shopify stores in a single run
- **Full product catalog** — Title, vendor, type, tags, images, description
- **Pricing intelligence** — Price ranges, compare-at prices, discount detection
- **Variant details** — SKU, sizes, colors, individual pricing, inventory quantity
- **Store summary** — Price analytics, vendor distribution, stock status, product types
- **Collection extraction** — Store categories and collections with metadata
- **Validated output** — Anti-placeholder guardrails ensure only real data
- **Pay per result** — $0.05/product

### 📥 Input

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `storeUrls` | string[] | Yes | — | Shopify store URLs (e.g., `"https://allbirds.com"`). Max 50. |
| `maxProductsPerStore` | integer | No | 250 | Max products to extract per store (1-5000) |
| `includeCollections` | boolean | No | true | Also fetch store collections/categories |
| `includeVariants` | boolean | No | true | Include product variants (sizes, colors, SKUs) |
| `proxyConfiguration` | object | No | — | Proxy settings (usually not needed) |

#### Input Example

```json
{
  "storeUrls": [
    "https://allbirds.com",
    "https://gymshark.com",
    "https://colourpop.com"
  ],
  "maxProductsPerStore": 250,
  "includeCollections": true,
  "includeVariants": true
}
````

### 📤 Output

Each run produces three types of results: **store\_summary**, **product**, and **collection**.

#### Product Fields

| Field | Type | Description |
|---|---|---|
| `type` | string | Always `"product"` |
| `productId` | number | Shopify product ID |
| `title` | string | Product name |
| `handle` | string | URL slug |
| `url` | string | Full product URL |
| `vendor` | string | Product vendor/brand |
| `productType` | string | Product category |
| `tags` | string\[] | Product tags |
| `price` | number | Minimum price |
| `priceMax` | number | Maximum price |
| `currency` | string | Currency (store-dependent) |
| `compareAtPrice` | number | Original price (before discount) |
| `hasDiscount` | boolean | Whether product is on sale |
| `discountPercent` | number | Discount percentage |
| `variantCount` | number | Total variant count |
| `availableVariants` | number | In-stock variants |
| `inStock` | boolean | Whether product is available |
| `totalInventory` | number | Total inventory quantity |
| `variants` | object\[] | Variant details: {variantId, title, price, compareAtPrice, sku, available, inventoryQuantity, option1, option2, option3} |
| `imageCount` | number | Number of images |
| `mainImage` | string | Primary image URL |
| `description` | string | Product description (plain text, max 500 chars) |
| `createdAt` | string | Product creation date |
| `updatedAt` | string | Last update date |
| `publishedAt` | string | Publication date |
| `storeDomain` | string | Store domain |
| `storeUrl` | string | Store base URL |
| `platform` | string | Always `"shopify"` |
| `scrapedAt` | string | ISO 8601 timestamp |

#### Store Summary Fields

| Field | Type | Description |
|---|---|---|
| `type` | string | Always `"store_summary"` |
| `storeDomain` | string | Store domain name |
| `productCount` | number | Total products found |
| `collectionCount` | number | Total collections found |
| `priceMin` | number | Lowest product price |
| `priceMax` | number | Highest product price |
| `priceAvg` | number | Average product price |
| `priceMedian` | number | Median product price |
| `productsInStock` | number | Products currently available |
| `productsOutOfStock` | number | Products out of stock |
| `productsOnSale` | number | Products with active discounts |
| `uniqueVendors` | number | Number of distinct vendors |
| `topVendors` | object\[] | Top 10 vendors by product count |
| `topProductTypes` | object\[] | Top 10 product types |

#### Output Example

```json
{
  "type": "product",
  "productId": 6654018298022,
  "title": "Men's Tree Runners",
  "handle": "mens-tree-runners",
  "url": "https://allbirds.com/products/mens-tree-runners",
  "vendor": "Allbirds",
  "productType": "Shoes",
  "tags": ["men", "runners", "tree"],
  "price": 98.00,
  "priceMax": 98.00,
  "currency": "USD",
  "compareAtPrice": 0,
  "hasDiscount": false,
  "discountPercent": 0,
  "variantCount": 12,
  "availableVariants": 10,
  "inStock": true,
  "totalInventory": 847,
  "variants": [
    {
      "variantId": 39847261839542,
      "title": "8 / Basin Blue (Medium Blue)",
      "price": 98.00,
      "compareAtPrice": 0,
      "sku": "TR-M-BB-8",
      "available": true,
      "inventoryQuantity": 73,
      "option1": "8",
      "option2": "Basin Blue (Medium Blue)",
      "option3": ""
    }
  ],
  "imageCount": 6,
  "mainImage": "https://cdn.shopify.com/s/files/1/0197/9501/products/tree-runner-mens.jpg",
  "description": "Light on your feet, and easy on the planet. Made with breathable tree fiber...",
  "createdAt": "2023-01-15T10:30:00-05:00",
  "updatedAt": "2026-03-01T14:22:00-05:00",
  "publishedAt": "2023-01-15T10:30:00-05:00",
  "storeDomain": "allbirds.com",
  "storeUrl": "https://allbirds.com",
  "platform": "shopify",
  "scrapedAt": "2026-03-06T12:00:00.000Z"
}
```

### 📋 Use Cases

- **Competitive Intelligence** — Monitor competitor product catalogs, pricing strategies, and inventory levels
- **Price Monitoring** — Track price changes, discounts, and compare-at pricing across stores
- **Market Research** — Analyze product categories, vendor distribution, and pricing ranges
- **Inventory Tracking** — Monitor stock availability and variant-level inventory
- **E-commerce Analytics** — Compare store sizes, product assortments, and pricing tiers
- **Dropshipping Research** — Discover trending products, vendors, and pricing patterns

### ❓ FAQ

**Q: How do I know if a store is built on Shopify?**
A: Most Shopify stores expose a `/products.json` endpoint. You can test by adding `/products.json` to any store URL. If it returns JSON data, the store is Shopify-powered. The actor will skip non-Shopify URLs gracefully.

**Q: Does this work with password-protected stores?**
A: No. The actor uses Shopify's public JSON API, which only works for stores that have public access. Password-protected or private stores will return null and be skipped.

**Q: Why is `currency` showing as "USD" for all stores?**
A: Shopify's public `/products.json` endpoint does not include currency information. The actor defaults to "USD" but the actual currency depends on the store's settings. Check the store's website for the correct currency.

**Q: Can I extract more than 250 products from a store?**
A: Yes. Set `maxProductsPerStore` up to 5000. The actor automatically paginates through Shopify's API (250 products per page) until the limit is reached.

**Q: What is included in the store\_summary result?**
A: The store summary includes aggregated analytics: total product count, price range (min/max/avg/median), in-stock vs out-of-stock counts, discount analysis, top vendors by product count, and top product types.

### 💰 Pricing

This actor uses **Pay Per Event (PPE)** pricing:

| Metric | Cost |
|--------|------|
| product-scraped | $0.05 per product |

For example, extracting 250 products from one store costs $12.50. Note: store summaries and collections are also counted as items.

### 🔗 Related Actors

- [TradingView Screener](https://apify.com/viralanalyzer/tradingview-screener) — Stock technical analysis
- [Yahoo Finance Intelligence](https://apify.com/viralanalyzer/yahoo-finance-intelligence) — Stock fundamentals
- [Google Maps BR Scraper](https://apify.com/viralanalyzer/google-maps-br-scraper) — Business data extraction
- [Instagram Reels Scraper](https://apify.com/viralanalyzer/instagram-reels-scraper) — Instagram metrics

### 📝 Changelog

#### v1.0 (Current)

- Multi-store product extraction via /products.json API
- Full variant details with pricing, SKU, and inventory
- Collection/category extraction
- Store summary with price analytics and vendor breakdown
- Discount detection and percentage calculation
- Anti-placeholder guardrails for data integrity
- Rate limit handling with automatic retries
- PPE billing integration

***

<a name="português"></a>

## 🛍️ Shopify Store Intelligence — Produtos, Preços, Estoque & Análise Competitiva

> 🔗 [Ver na Apify Store](https://apify.com/viralanalyzer/shopify-store-intelligence) | [🇺🇸 English](#-shopify-store-intelligence--products-prices-inventory--competitive-analysis) | 🇧🇷 Português

Extraia **catálogos de produtos, preços, variantes, status de estoque e coleções** de qualquer loja Shopify. Usa a API JSON pública do Shopify — ultra-rápido, HTTP puro, sem navegador.

### ✨ Funcionalidades

- **Análise multi-loja** — Analise até 50 lojas Shopify em uma única execução
- **Catálogo completo** — Título, fabricante, tipo, tags, imagens, descrição
- **Inteligência de preços** — Faixas de preço, preços comparativos, detecção de descontos
- **Detalhes de variantes** — SKU, tamanhos, cores, preços individuais, quantidade em estoque
- **Resumo da loja** — Análise de preços, distribuição de fabricantes, status de estoque
- **Extração de coleções** — Categorias e coleções da loja com metadados
- **Saída validada** — Guardrails anti-placeholder garantem apenas dados reais
- **Pague por resultado** — $0.05/produto

### 📥 Entrada

| Parâmetro | Tipo | Obrigatório | Padrão | Descrição |
|---|---|---|---|---|
| `storeUrls` | string\[] | Sim | — | URLs das lojas Shopify (ex: `"https://allbirds.com"`). Máximo 50. |
| `maxProductsPerStore` | inteiro | Não | 250 | Máximo de produtos por loja (1-5000) |
| `includeCollections` | boolean | Não | true | Também buscar coleções/categorias da loja |
| `includeVariants` | boolean | Não | true | Incluir variantes de produto (tamanhos, cores, SKUs) |
| `proxyConfiguration` | objeto | Não | — | Configuração de proxy (geralmente desnecessário) |

#### Exemplo de Entrada

```json
{
  "storeUrls": [
    "https://allbirds.com",
    "https://gymshark.com",
    "https://colourpop.com"
  ],
  "maxProductsPerStore": 250,
  "includeCollections": true,
  "includeVariants": true
}
```

### 📤 Saída

Cada execução produz três tipos de resultado: **store\_summary**, **product** e **collection**.

#### Campos do Produto

| Campo | Tipo | Descrição |
|---|---|---|
| `type` | string | Sempre `"product"` |
| `productId` | número | ID do produto no Shopify |
| `title` | string | Nome do produto |
| `handle` | string | Slug da URL |
| `url` | string | URL completa do produto |
| `vendor` | string | Fabricante/marca |
| `productType` | string | Categoria do produto |
| `tags` | string\[] | Tags do produto |
| `price` | número | Preço mínimo |
| `priceMax` | número | Preço máximo |
| `currency` | string | Moeda (depende da loja) |
| `compareAtPrice` | número | Preço original (antes do desconto) |
| `hasDiscount` | boolean | Se o produto está em promoção |
| `discountPercent` | número | Percentual de desconto |
| `variantCount` | número | Total de variantes |
| `availableVariants` | número | Variantes em estoque |
| `inStock` | boolean | Se o produto está disponível |
| `totalInventory` | número | Quantidade total em estoque |
| `variants` | objeto\[] | Detalhes das variantes: {variantId, title, price, compareAtPrice, sku, available, inventoryQuantity, option1, option2, option3} |
| `imageCount` | número | Número de imagens |
| `mainImage` | string | URL da imagem principal |
| `description` | string | Descrição (texto puro, máximo 500 caracteres) |
| `createdAt` | string | Data de criação |
| `updatedAt` | string | Data da última atualização |
| `publishedAt` | string | Data de publicação |
| `storeDomain` | string | Domínio da loja |
| `storeUrl` | string | URL base da loja |
| `platform` | string | Sempre `"shopify"` |
| `scrapedAt` | string | Timestamp ISO 8601 |

#### Campos do Resumo da Loja

| Campo | Tipo | Descrição |
|---|---|---|
| `type` | string | Sempre `"store_summary"` |
| `storeDomain` | string | Domínio da loja |
| `productCount` | número | Total de produtos encontrados |
| `collectionCount` | número | Total de coleções |
| `priceMin` | número | Menor preço |
| `priceMax` | número | Maior preço |
| `priceAvg` | número | Preço médio |
| `priceMedian` | número | Preço mediano |
| `productsInStock` | número | Produtos disponíveis |
| `productsOutOfStock` | número | Produtos esgotados |
| `productsOnSale` | número | Produtos em promoção |
| `uniqueVendors` | número | Fabricantes distintos |
| `topVendors` | objeto\[] | Top 10 fabricantes por quantidade |
| `topProductTypes` | objeto\[] | Top 10 tipos de produto |

#### Exemplo de Saída

```json
{
  "type": "product",
  "productId": 6654018298022,
  "title": "Men's Tree Runners",
  "handle": "mens-tree-runners",
  "url": "https://allbirds.com/products/mens-tree-runners",
  "vendor": "Allbirds",
  "productType": "Shoes",
  "tags": ["men", "runners", "tree"],
  "price": 98.00,
  "priceMax": 98.00,
  "currency": "USD",
  "compareAtPrice": 0,
  "hasDiscount": false,
  "discountPercent": 0,
  "variantCount": 12,
  "availableVariants": 10,
  "inStock": true,
  "totalInventory": 847,
  "variants": [
    {
      "variantId": 39847261839542,
      "title": "8 / Basin Blue (Medium Blue)",
      "price": 98.00,
      "compareAtPrice": 0,
      "sku": "TR-M-BB-8",
      "available": true,
      "inventoryQuantity": 73,
      "option1": "8",
      "option2": "Basin Blue (Medium Blue)",
      "option3": ""
    }
  ],
  "imageCount": 6,
  "mainImage": "https://cdn.shopify.com/s/files/1/0197/9501/products/tree-runner-mens.jpg",
  "description": "Light on your feet, and easy on the planet. Made with breathable tree fiber...",
  "createdAt": "2023-01-15T10:30:00-05:00",
  "updatedAt": "2026-03-01T14:22:00-05:00",
  "publishedAt": "2023-01-15T10:30:00-05:00",
  "storeDomain": "allbirds.com",
  "storeUrl": "https://allbirds.com",
  "platform": "shopify",
  "scrapedAt": "2026-03-06T12:00:00.000Z"
}
```

### 📋 Casos de Uso

- **Inteligência Competitiva** — Monitore catálogos, estratégias de preço e estoque de concorrentes
- **Monitoramento de Preços** — Acompanhe mudanças de preço, descontos e preços comparativos
- **Pesquisa de Mercado** — Analise categorias, distribuição de fabricantes e faixas de preço
- **Rastreamento de Estoque** — Monitore disponibilidade e estoque por variante
- **Analytics E-commerce** — Compare tamanho de lojas, sortimento e faixas de preço
- **Pesquisa Dropshipping** — Descubra produtos em alta, fabricantes e padrões de preço

### ❓ Perguntas Frequentes

**P: Como sei se uma loja é construída no Shopify?**
R: A maioria das lojas Shopify expõe um endpoint `/products.json`. Você pode testar adicionando `/products.json` a qualquer URL de loja. Se retornar dados JSON, a loja usa Shopify. O actor pula URLs não-Shopify de forma elegante.

**P: Funciona com lojas protegidas por senha?**
R: Não. O actor usa a API JSON pública do Shopify, que só funciona para lojas com acesso público. Lojas protegidas por senha ou privadas retornarão null e serão ignoradas.

**P: Por que `currency` mostra "USD" para todas as lojas?**
R: O endpoint público `/products.json` do Shopify não inclui informações de moeda. O actor usa "USD" como padrão, mas a moeda real depende das configurações da loja. Verifique o site da loja para a moeda correta.

**P: Posso extrair mais de 250 produtos de uma loja?**
R: Sim. Configure `maxProductsPerStore` até 5000. O actor pagina automaticamente através da API do Shopify (250 produtos por página) até atingir o limite.

**P: O que está incluído no resultado store\_summary?**
R: O resumo da loja inclui análises agregadas: total de produtos, faixa de preço (mínimo/máximo/média/mediana), contagem em estoque vs esgotado, análise de descontos, top fabricantes por quantidade de produtos, e top tipos de produto.

### 💰 Preços

Este actor usa precificação **Pay Per Event (PPE)**:

| Métrica | Custo |
|---------|-------|
| product-scraped | $0.05 por produto |

Por exemplo, extrair 250 produtos de uma loja custa $12.50. Nota: resumos de loja e coleções também são contados como itens.

### 🔗 Actors Relacionados

- [TradingView Screener](https://apify.com/viralanalyzer/tradingview-screener) — Análise técnica de ações
- [Yahoo Finance Intelligence](https://apify.com/viralanalyzer/yahoo-finance-intelligence) — Fundamentos de ações
- [Google Maps BR Scraper](https://apify.com/viralanalyzer/google-maps-br-scraper) — Dados de empresas
- [Instagram Reels Scraper](https://apify.com/viralanalyzer/instagram-reels-scraper) — Métricas do Instagram

### 📝 Changelog

#### v1.0 (Atual)

- Extração multi-loja via API /products.json
- Detalhes completos de variantes com preço, SKU e estoque
- Extração de coleções/categorias
- Resumo da loja com analytics de preço e fabricantes
- Detecção de descontos e cálculo de percentual
- Guardrails anti-placeholder para integridade de dados
- Tratamento de rate limit com retentativas automáticas
- Integração com cobrança PPE

# Actor input Schema

## `storeUrls` (type: `array`):

List of Shopify store URLs to analyze (e.g., 'https://allbirds.com', 'gymshark.com'). Supports with or without https://.

## `includeCollections` (type: `boolean`):

Also fetch store collections/categories.

## `maxProductsPerStore` (type: `integer`):

Maximum number of products to extract per store. Shopify returns 250 per page.

## `includeVariants` (type: `boolean`):

Include all product variants (sizes, colors, etc.) with individual pricing.

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

Proxy settings. Usually not needed — Shopify's JSON API is public.

## Actor input object example

```json
{
  "storeUrls": [
    "https://allbirds.com"
  ],
  "includeCollections": true,
  "maxProductsPerStore": 250,
  "includeVariants": true
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing all scraped results. Each item follows the dataset schema.

# 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 = {
    "storeUrls": [
        "https://allbirds.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("viralanalyzer/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 = { "storeUrls": ["https://allbirds.com"] }

# Run the Actor and wait for it to finish
run = client.actor("viralanalyzer/shopify-store-intelligence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "storeUrls": [
    "https://allbirds.com"
  ]
}' |
apify call viralanalyzer/shopify-store-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=viralanalyzer/shopify-store-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Intelligence",
        "description": "Analyze Shopify stores: extract products, prices, collections, themes, and apps. Competitive e-commerce intelligence.",
        "version": "1.0",
        "x-build-id": "auyLGY1oxaozkLU5L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/viralanalyzer~shopify-store-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-viralanalyzer-shopify-store-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/viralanalyzer~shopify-store-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-viralanalyzer-shopify-store-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/viralanalyzer~shopify-store-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-viralanalyzer-shopify-store-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "storeUrls"
                ],
                "properties": {
                    "storeUrls": {
                        "title": "Shopify Store URLs",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "List of Shopify store URLs to analyze (e.g., 'https://allbirds.com', 'gymshark.com'). Supports with or without https://.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeCollections": {
                        "title": "Include Collections",
                        "type": "boolean",
                        "description": "Also fetch store collections/categories.",
                        "default": true
                    },
                    "maxProductsPerStore": {
                        "title": "Max Products Per Store",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to extract per store. Shopify returns 250 per page.",
                        "default": 250
                    },
                    "includeVariants": {
                        "title": "Include Product Variants",
                        "type": "boolean",
                        "description": "Include all product variants (sizes, colors, etc.) with individual pricing.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Usually not needed — Shopify's JSON API is public."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```