# Shopify Store Analyzer — No Login, Apps, Emails & Phones (`apivault_labs/shopify-store-analyzer`) Actor

Analyze public Shopify catalog and app signals; revenue and sales estimates are labeled assumptions. No login. Bulk export: JSON, CSV, Excel and API. PPE: from $4/1K store analyses; start fee, usage extra.

- **URL**: https://apify.com/apivault_labs/shopify-store-analyzer.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 475 total users, 60 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $7.00 / 1,000 store analyzeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 — No Login, Apps, Emails & Phones

Research a Shopify store before your next pitch or product decision. Get **visible apps, public business contacts, product and price data**, plus optional traffic and revenue estimates, in one exportable store profile.

[![Shopify Store Analyzer — apps, contacts, products and competitor research](https://raw.githubusercontent.com/apivault-labs/apivault-labs/main/assets/shopify-store-analyzer/hero-v2-20261113.png)](https://console.apify.com/actors/9twVh4isboNg2w6bg/input)

| Decide in seconds | What you get |
|---|---|
| **Best for** | Agency prospect research, app targeting and competitor comparisons |
| **Start with** | Store URLs, a niche keyword or one competitor URL |
| **Output** | One store profile per result; CSV, Excel, JSON, API, n8n and MCP |
| **Result price** | **$7–15 per 1,000 results** now; lower Free–Gold prices from **27 November 2026** |
| **Extra costs** | $0.0005 start event; Apify platform and proxy usage billed separately |
| **Access** | No Shopify storefront login or separate data-provider key; Apify account required |

**[Analyze your first store](https://console.apify.com/actors/9twVh4isboNg2w6bg/input)** — paste one URL, run a small sample and review the result before scaling.

Contacts and app signals depend on public-source coverage. Revenue and traffic are estimates; contact availability and mailbox deliverability are not guaranteed.

### Quick start: analyze one Shopify store

Paste a store URL, choose a small product sample and run the Actor:

```json
{
  "mode": "analyze",
  "storeUrls": ["https://boody.com.au"],
  "outputPreset": "compact",
  "productSampleSize": 10,
  "maxStores": 1,
  "trackChanges": false,
  "generateComparison": false
}
```

Open the Dataset for the store profile, then inspect `SUMMARY` and `ERRORS` in the run's key-value store. Check `data_quality` before using optional fields. Expand to a larger batch after reviewing the first result and the [current pricing](https://apify.com/apivault_labs/shopify-store-analyzer/pricing).

### Who is this Shopify research tool for?

| Your goal | How to use the Actor | What to review |
|---|---|---|
| Shopify agencies and freelancers | Enrich a domain list with public contacts, visible apps and catalog context | Confirm service fit and current website needs manually |
| Shopify app developers | Find niche stores with a detected review, email, subscription or support app | Detection reflects visible signals, not a complete installed-app inventory |
| Ecommerce brands | Compare competitor product samples, prices, promotions and technology | Compare the same currency and understand each catalog's sample scope |
| Market researchers | Discover merchant candidates by product niche and merchant-origin country | Discovery is a bounded sample, not an exhaustive merchant directory |
| Sales operations and analysts | Export structured Shopify lead research into a spreadsheet or workflow | Contact availability and commercial relevance vary by store |
| AI agents and automation builders | Request compact, leads or monitoring output through API/MCP | Read diagnostics and spending limits before expanding a run |

The Actor collects research data. It does not send emails, place calls, verify mailbox deliverability or establish a merchant's purchase intent.

### What data can you get from a Shopify store?

| Data group | Example fields and observations |
|---|---|
| Store identity | `domain`, store name/URL, available `myshopify_domain`, public country/city and platform classification |
| Apps and technology | `tech_stack`, detected app categories, available theme metadata and public tracking signals |
| Public business contacts | `emails`, `phones`, `best_email` and available social-profile links |
| Product and price research | `sampled_products`, sampled product counts, available titles/prices, price statistics and `price_currency` |
| Catalog coverage | `catalog_source`, `catalog_complete`, `catalog_sample_basis` and source-availability diagnostics |
| Discovery provenance | `search_term`, `discovered_via`, `discovery_scope`, `discovery_page` and `country_basis` |
| Monitoring and comparison | `changes`, comparable catalog observations and an optional `COMPARISON_REPORT` |
| Optional analytical signals | Traffic inputs, revenue assumptions, health/lead/opportunity scores and other research heuristics |

Fields vary by mode, extraction flags, output preset and source response. Missing email, phone, traffic or revenue is not a verified zero. Use `full` when you need the available detailed fields; smaller presets intentionally omit parts of the record.

### Choose a workflow

![Shopify Analyzer workflows — analyze, discover, compare and monitor](https://raw.githubusercontent.com/apivault-labs/apivault-labs/main/assets/shopify-store-analyzer/workflows.svg)

| `mode` | Use it when | Main input |
|---|---|---|
| `analyze` | You already have Shopify store URLs | `storeUrls` |
| `discover` | You want store candidates matching a niche | `searchTerms` |
| `discover_and_analyze` | You want discovery followed by richer store analysis | `searchTerms` |
| `find_similar` | You have a seed store and want niche-related candidates | `seedStoreUrl` |
| `quick_check` | You want to classify a list of websites | `storeUrls` |

#### Shopify store discovery and lead generation

Find merchant candidates selling a product type, then collect their available public contacts:

```json
{
  "mode": "discover",
  "searchTerms": ["organic coffee"],
  "maxStores": 3,
  "enrichContacts": true,
  "outputPreset": "leads"
}
```

Discovery uses Shopify's documented public Catalog MCP search to find actual seller URLs from matching products. It follows opaque pagination cursors for at most five product pages per term, deduplicates store domains and stops at your limit. No Shop account or additional Catalog key is required.

Treat results as a bounded product-seller sample. They are not a full Shopify store database, a list of every merchant in a country or a verified ranking of the best stores in a niche. `discoverCountry` applies a Catalog merchant-origin filter; it does not verify headquarters or legal registration. Source warnings remain in `discovery_warnings`.

#### Shopify app detector and technology research

Research what apps a Shopify store visibly uses: email/SMS tools, review widgets, subscriptions, customer support, page builders, analytics and payment signals. Recognizable fingerprints include Klaviyo, Omnisend, Judge.me, Yotpo, Loox, ReCharge, Gorgias, PageFly and other supported technologies.

For reverse app lookup, combine niche discovery with a required app:

```json
{
  "mode": "discover_and_analyze",
  "searchTerms": ["organic coffee"],
  "requiredApps": ["Klaviyo"],
  "appMatchMode": "any",
  "maxStores": 3,
  "productSampleSize": 10,
  "outputPreset": "leads",
  "trackChanges": false
}
```

In discovery workflows, `requiredApps` keeps detected matches; `appMatchMode` accepts `any` or `all`. `excludeApps` removes candidates with the specified detected signals. These filters may produce no matches from the bounded search sample; they do not trigger an exhaustive scan of Shopify.

Apps are detected from accessible public evidence. An app can be installed without exposing a recognizable signal, or an old public reference can remain after a change. **No detected app is not proof that the merchant does not use it.** Verify important findings on the store before making a sales claim. Tracking pixels do not establish active ads, ad spend or common ownership between stores.

#### Shopify email extractor and phone finder

Enrich known Shopify domains with public contact details and social links. `extractContact` enables contact discovery; `deepContactCrawl` enables the additional bounded public-page checks implemented by the Actor. This example reduces unrelated catalog and estimate work:

```json
{
  "mode": "analyze",
  "storeUrls": ["https://boody.com.au"],
  "outputPreset": "leads",
  "maxStores": 1,
  "extractContact": true,
  "deepContactCrawl": true,
  "extractSocials": true,
  "extractProducts": false,
  "extractTraffic": false,
  "extractRevenueEstimate": false,
  "extractDerivedSignals": false,
  "trackChanges": false,
  "generateComparison": false
}
```

`best_email` is the selected discovered address, not proof of ownership, mailbox validity or access to a decision-maker. Contact information is returned only when publicly found; some stores expose a form instead of an email or phone. Review the originating business and your intended use before adding contacts to a CRM.

#### Shopify competitor analysis and similar-store discovery

Use a seed store to find candidate competitors selling related products:

```json
{
  "mode": "find_similar",
  "seedStoreUrl": "https://deathwishcoffee.com",
  "maxStores": 3,
  "outputPreset": "leads",
  "enrichContacts": true
}
```

Similar stores are inferred niche candidates. They are not verified direct competitors, a market-share ranking or evidence that one business copies another. Review product overlap and the actual market yourself.

To compare known stores, analyze their URLs together and enable the comparison report:

```json
{
  "mode": "analyze",
  "storeUrls": ["https://boody.com.au", "https://allbirds.com"],
  "maxStores": 2,
  "productSampleSize": 10,
  "outputPreset": "full",
  "generateComparison": true,
  "trackChanges": false
}
```

The run writes `COMPARISON_REPORT` to its key-value store. Compare observed technology, available contacts and product-price context. The report is included; it is not an extra charged Dataset row. Different catalog coverage or currencies can make direct comparisons misleading.

#### Shopify product catalog scraper and pricing research

Use `productSampleSize` to bound product sampling and `extractProducts` to control catalog analysis. Depending on source availability, results can include sampled products, price ranges, product types, vendors, sale indicators, collection information and product publication signals.

Always read `catalog_source`, `catalog_complete` and `catalog_sample_basis`. An alternate marketplace route can return a strictly store-matched regional sample; it is not equivalent to the store's full catalog. A small sample can miss product types, variants, stock changes or new launches. `price_currency` identifies actual sampled prices, rather than assuming USD.

Best-seller research needs an additional distinction: `best_sellers_basis: "store-curated collection"` reflects observed collection order. `"catalog heuristic"` ranks sampled products using catalog clues and is **not verified sales** or confirmed best-seller volume. This Actor does not read private order history.

#### Shopify store monitoring and change tracking

Track supported changes from your own prior observations:

```json
{
  "mode": "analyze",
  "storeUrls": ["https://boody.com.au"],
  "maxStores": 1,
  "productSampleSize": 10,
  "outputPreset": "monitoring",
  "trackChanges": true,
  "generateComparison": false
}
```

The first snapshot creates a baseline in your account's named `shopify-analyzer-snapshots` key-value store. Later runs compare with that account's previous domain snapshot. Tasks in the same account share this history; retain the named store to preserve it. Schedule repeated runs in Apify if you want recurring observations.

Product additions and removals require comparable complete catalogs. Limited samples and unavailable comparisons are explicitly skipped, so a missing sampled product is not reported as a confirmed removal. Monitoring begins with your first retained snapshot; it does not reconstruct historical changes from before your runs.

#### Shopify checker: classify website URLs

```json
{
  "mode": "quick_check",
  "storeUrls": ["https://boody.com.au", "https://example.com"],
  "maxStores": 2,
  "outputPreset": "compact",
  "trackChanges": false
}
```

Use this workflow to inspect platform classifications before a deeper analysis. A reachable non-Shopify classification is a useful billable result. An unreachable URL goes to diagnostics instead of creating a charged Dataset row. Source restrictions can prevent a reliable classification; examine `reachable`, `classification_verified` and the diagnostics rather than treating every missing Shopify signal as a negative result.

### Revenue estimates, traffic and research scores

The Shopify revenue estimator is an optional model based on available inputs and configurable assumptions. It does not provide verified merchant turnover, private transactions, actual conversion rates or order counts. Traffic and review-derived methods can be incomplete or unavailable.

Read the method, assumptions, local currency amounts and available dated FX information in `revenue_estimate`. USD remains null when necessary inputs or the exchange rate are unavailable. `conversionRate` and `reviewsToSalesMultiplier` are modeling inputs, not measured facts about the store. Estimates have not been validated against merchant financials.

Health, lead, opportunity and dropshipper scores summarize public signals using heuristics. Use them to prioritize manual research, not to certify store quality, business risk or buying intent. “No app detected” pitch suggestions require the same manual verification as app detection itself.

### Inputs and output presets

| Input | Practical use |
|---|---|
| `maxStores` | Cap the number of stores for the selected workflow |
| `productSampleSize` | Bound the product sample; a sample is not a full-catalog guarantee |
| `discoverCountry` | Optional ISO-2 merchant-origin filter for discovery, such as `US` |
| `requiredApps`, `excludeApps` | Apply detected-technology filters in discovery workflows |
| `extractTechStack`, `extractContact`, `extractSocials` | Select the public information you need |
| `extractTraffic`, `extractRevenueEstimate` | Control optional traffic/model-based research |
| `trackChanges`, `generateComparison` | Control history and multi-store comparison |
| `maxConcurrency`, `timeout` | Request processing limits; actual concurrency is also constrained by available memory |

`minMonthlyVisits`, `minStoreHealth` and `minOpportunityScore` are qualification controls for the supported analysis flow. A missing input metric can prevent a candidate from passing a positive threshold. Do not interpret a filtered-out record as proof that the business has no traffic or opportunity.

| `outputPreset` | Best use |
|---|---|
| `compact` | Small profiles with core metrics, best email and detected apps |
| `leads` | Public contacts, socials, technology and qualification signals |
| `monitoring` | Changes, catalog coverage, prices and trend observations |
| `full` | Available detailed fields and the complete legacy record |

Omitting `outputPreset` preserves the legacy `full` response. Set `flatOutput: true` to flatten the selected preset. A preset changes the returned projection; it does not automatically turn every underlying extraction option off. Disable optional extraction flags explicitly when you do not need that work.

### API, MCP, n8n and Python automation

Use the [Actor API](https://apify.com/apivault_labs/shopify-store-analyzer/api) to start a bounded run, retain its run ID, wait for completion and read the Dataset. Export JSON, CSV or Excel through Apify. When connecting a spreadsheet or CRM, map the available fields and handle missing contacts and partial results explicitly.

Hosted MCP endpoint: `https://mcp.apify.com?tools=apivault_labs/shopify-store-analyzer`

Tool name: `apivault_labs--shopify-store-analyzer`. Send `mode` explicitly and start with one store plus `outputPreset: "compact"`. Inspect the Dataset, `SUMMARY` and `ERRORS` before expanding. The four output presets belong to the same Actor, not different installed versions.

### n8n and developer integrations

Use this Actor in your automation or application with the existing community integrations below. An Apify account and API token are required; Actor and platform charges follow the [current pricing](https://apify.com/apivault_labs/shopify-store-analyzer/pricing).

- **n8n community node:** [n8n-nodes-apivault-shopify-analyzer](https://www.npmjs.com/package/n8n-nodes-apivault-shopify-analyzer). Install package name `n8n-nodes-apivault-shopify-analyzer` in a self-hosted n8n instance that permits community packages.
- **n8n source and usage:** [GitHub](https://github.com/apivault-labs/n8n-nodes-apivault-shopify-analyzer).
- **Python client and examples:** [GitHub](https://github.com/apivault-labs/shopify-store-analyzer-python).
- **n8n source and usage:** [GitHub](https://github.com/apivault-labs/apivault-labs/tree/main/community-nodes/n8n-nodes-apivault-shopify-analyzer).

These are community packages. Publication on npm does not establish n8n verification or availability in n8n Cloud. Review the linked package README for supported inputs and setup.

For Python, review the linked client's supported parameters. The existing Python client exposes the legacy URL-analysis interface; use the Actor API directly when you need discovery or output-preset controls that the client does not expose. A client-side historical cost estimate is not the live Apify tariff.

### Pricing and spending control

**Current range: $7–15 per 1,000 results. Scheduled range: $5–13.** Returned store rows are charged per result, with a lower price on higher Apify plans. **New Free, Bronze, Silver and Gold rates take effect on 27 November 2026 at 13:44 UTC (16:44 Minsk).** Apify requires two weeks of notice; current rates apply until then.

| Apify plan | Current / 1,000 results | From 27 November / 1,000 results |
|---|---:|---:|
| Free | $15 | $13 |
| Starter (Bronze) | $12 | $10 |
| Scale (Silver) | $9 | $7 |
| Business (Gold) | $7 | $5 |

These are **result-event prices**, not total run cost. A **$0.0005 start event** applies per run. **Apify platform and proxy usage are paid separately by the user.** Check [current pricing](https://apify.com/apivault_labs/shopify-store-analyzer/pricing) before a larger batch.

One returned record is the result-billing unit; contacts or apps within that record are not separate result events. Reachable non-Shopify classifications are billable. Filtered-out stores, unreachable URLs and input diagnostics do not create charged Dataset rows. Start and platform costs can still apply to empty runs. Begin with a small limit and set a maximum total charge in Apify.

### Frequently asked questions

#### Can I find out what apps a Shopify store uses?

The Actor detects supported public app and technology fingerprints. It does not authenticate to Shopify Admin or enumerate private installed apps. A blocked homepage or missing fingerprint cannot establish app absence.

#### Can I find Shopify store emails and phone numbers?

Yes, when those contacts are publicly discoverable on supported pages. Coverage varies. A returned email is a discovered contact, not a verified mailbox, a guaranteed owner email or permission to contact that person.

#### Can I discover Shopify stores without a URL list?

Use `discover` or `discover_and_analyze` with `searchTerms`. The bounded Catalog product search returns seller candidates. It is not an exhaustive Shopify directory export, and restrictive app/country filters can return no matches.

#### Does this show exact Shopify revenue or best-selling products?

No private sales data is accessed. Revenue is a model with disclosed assumptions. Best-seller fields identify either observed store-curated collection order or a catalog heuristic; neither establishes actual sales volume.

#### Does “no login” mean the Actor is free or anonymous?

No storefront login or separate data-provider key is needed. Running through Apify requires an account; API, n8n and MCP integrations require the appropriate Apify credential. Result, start and usage charges follow the current tariff.

#### Why can a successful run return partial data?

Optional sources can be restricted, time out or expose only a limited sample. `SUMMARY.status` distinguishes `COMPLETED`, `PARTIAL_RESULTS`, `NO_RESULTS`, `INVALID_INPUT` and source/storage failures. Review `partialRows`, `partialStores`, `data_quality` and structured `ERRORS`; successful run status alone does not prove complete coverage. Do not treat a source failure as a successful search with zero merchants.

#### Is the community node verified for n8n Cloud?

npm publication is not n8n verification or confirmation of n8n Cloud availability. The linked community package is intended for n8n installations that permit such packages; check its current setup documentation.

### Ready-to-run Shopify research Tasks

- [Analyze one Shopify store](https://apify.com/apivault_labs/shopify-store-analyzer/examples/analyze-one-shopify-store-agent-demo)
- [Research a store's modeled monthly revenue](https://apify.com/apivault_labs/shopify-store-analyzer/examples/estimate-a-shopify-stores-monthly-revenue)
- [Detect visible Shopify apps](https://apify.com/apivault_labs/shopify-store-analyzer/examples/detect-which-apps-a-shopify-store-uses)
- [Find public store contact emails](https://apify.com/apivault_labs/shopify-store-analyzer/examples/get-contact-emails-for-shopify-stores)
- [Monitor competitor-store observations](https://apify.com/apivault_labs/shopify-store-analyzer/examples/monitor-a-competitors-shopify-store-for-changes)

Replace sample URLs and niches with your own research targets, review the first records and diagnostics, and increase limits only when the observed coverage meets your needs.

# Changelog

This Actor's version history is a separate document: https://apify.com/apivault_labs/shopify-store-analyzer/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Required routing choice for API and AI agents. Use analyze with storeUrls, discover or discover_and_analyze with searchTerms, find_similar with seedStoreUrl, and quick_check for platform classification.

## `seedStoreUrl` (type: `string`):

In Find-similar mode: a Shopify store whose competitors you want. The Actor learns its niche from its products and returns other stores selling similar things.

## `searchTerms` (type: `array`):

Keywords or niches to find Shopify stores for, e.g. "organic coffee", "yoga mats". Used in Discover modes — returns real stores selling those products.

## `discoverCountry` (type: `string`):

ISO-2 Catalog merchant-origin filter, e.g. US, GB, CA, AU, DE, FR. Not a verified headquarters address. Leave empty for worldwide.

## `enrichContacts` (type: `boolean`):

In Discover mode, also fetch each store's public emails, phones and social handles — turning the store list into a lead list. Adds a little time per store.

## `requiredApps` (type: `array`):

Find stores that USE a specific app or technology, e.g. \["Klaviyo"], \["Yotpo"], \["ReCharge"]. In Discover modes, only stores whose detected tech stack matches are returned (others are skipped, not charged). Great for app vendors targeting stores that use a competitor. Leave empty to disable.

## `appMatchMode` (type: `string`):

When multiple apps are listed: 'any' keeps stores using at least one, 'all' keeps only stores using every listed app.

## `excludeApps` (type: `array`):

Skip stores whose tech stack uses any of these apps, e.g. \["Klaviyo"] to find stores that do NOT already have your tool. Combine with 'requiredApps' for precise targeting (uses Y but not Z).

## `minMonthlyVisits` (type: `integer`):

Only keep analyzed stores with at least this many estimated monthly visits. 0 = no filter. Build a qualified lead list (e.g. only stores with real traffic). Requires Traffic extraction.

## `minStoreHealth` (type: `integer`):

Only keep stores with a store_health_score at or above this. 0 = no filter.

## `minOpportunityScore` (type: `integer`):

Only keep stores with an opportunity_score at or above this (best sales targets). 0 = no filter.

## `maxStores` (type: `integer`):

Maximum stores returned. Start with a small discovery sample; source coverage may be limited. Upper input guard is 10000, not a guaranteed result count.

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

Shopify store homepages (max 100 per run). Bare domains or full URLs accepted. Used in Analyze mode.

## `conversionRate` (type: `number`):

Conversion rate used for the revenue estimate. Industry default 2.5%. Fashion 1.5-2%, electronics 1%, impulse-buy 3-4%.

## `productSampleSize` (type: `integer`):

How many products to sample for metrics. 0 = full catalog (hard-capped at 2000 to protect run memory). Default 250.

## `reviewsToSalesMultiplier` (type: `number`):

Tuning factor for the revenue estimate on smaller stores. Raise or lower to match your niche. Default 30.

## `outputPreset` (type: `string`):

Choose a smaller AI-friendly result or keep every legacy field. Leads focuses on contacts and qualification; Monitoring focuses on changes and time-series signals.

## `flatOutput` (type: `boolean`):

Flatten nested fields (traffic, revenue_estimate, socials…) into single underscore-joined columns, e.g. traffic_monthly_visits. Easier to map in automation tools and spreadsheets.

## `trackChanges` (type: `boolean`):

Compare trustworthy snapshots between runs. Product additions/removals require complete catalogs in both snapshots; samples and source failures are explicitly skipped. Missing website data does not mean apps were removed. Read changes for skipped comparisons.

## `extractProducts` (type: `boolean`):

Product count, AOV, price range, vendors, types, image counts, top tags (niche detection), duplicate description ratio (generic-catalog signal).

## `extractVelocity` (type: `boolean`):

New products in the collected sample in the last 7/30/90 days and its oldest date. Turn off to omit all velocity fields; limited samples are not full-store counts.

## `extractCollections` (type: `boolean`):

Collection count and top collections.

## `extractSitemap` (type: `boolean`):

Real total pages/products/collections/blogs across the whole store.

## `extractTraffic` (type: `boolean`):

Monthly visits, ranks, bounce rate, sources, top countries, keywords.

## `extractRevenueEstimate` (type: `boolean`):

Modeled orders and revenue using traffic and sampled prices, with a review-based fallback when possible. Local currency is preserved. USD requires a known price currency and dated FX; unavailable inputs produce null, not invented revenue.

## `extractTechStack` (type: `boolean`):

Detect 60+ Shopify apps (Klaviyo, Judge.me, ReCharge, Gorgias, dropshipping, payments) plus extract advertising IDs (GTM, GA4, Facebook Pixel, TikTok, Klaviyo public key, Hotjar) for brand-network mapping.

## `extractSocials` (type: `boolean`):

Instagram, Facebook, Twitter, TikTok, YouTube, Pinterest, LinkedIn handles.

## `extractContact` (type: `boolean`):

Public emails and phones from homepage.

## `deepContactCrawl` (type: `boolean`):

If the homepage shows no email, also check the store's contact / about pages for a public email and phone. Only fires when the homepage has none, so stores that already expose contact info cost no extra time. Improves the best_email hit rate for lead generation.

## `extractShopifyMeta` (type: `boolean`):

myshopify handle, currency, locale, theme, Shopify Plus indicator, and an account-age signal.

## `extractInternational` (type: `boolean`):

Localized languages, currency switcher, country selector, expansion score 0-100.

## `extractReviewsAggregate` (type: `boolean`):

Aggregate rating and total review count.

## `extractPromo` (type: `boolean`):

Free shipping threshold, active promo codes, announcement bar text, current discount %.

## `extractPolicyDetails` (type: `boolean`):

Fetch the store's refund & shipping policy pages to extract the returns window (days), free-returns and free-shipping signals. Off by default — adds two extra page fetches.

## `extractBrandAge` (type: `boolean`):

Brand age in years and founding year. Off by default: it's the slowest part of a run and only a secondary signal. An account-age signal is always available for free.

## `extractDerivedSignals` (type: `boolean`):

Customer segment, marketing channel mix, dropshipper risk score with reasons.

## `generateComparison` (type: `boolean`):

When analyzing 2+ stores in one run, add a single cross-store benchmarking report — rankings by traffic, revenue, AOV, discounting, international expansion and tech stack, plus shared-tech analysis and the cohort leader in each category. Included for all runs; turn off to skip the extra record.

## `maxConcurrency` (type: `integer`):

Parallel stores to analyze.

## `timeout` (type: `integer`):

HTTP timeout per request.

## Actor input object example

```json
{
  "mode": "analyze",
  "seedStoreUrl": "https://allbirds.com",
  "searchTerms": [
    "organic coffee"
  ],
  "enrichContacts": true,
  "appMatchMode": "any",
  "minMonthlyVisits": 0,
  "minStoreHealth": 0,
  "minOpportunityScore": 0,
  "maxStores": 10,
  "storeUrls": [
    "https://allbirds.com"
  ],
  "conversionRate": 2.5,
  "productSampleSize": 250,
  "reviewsToSalesMultiplier": 30,
  "outputPreset": "full",
  "flatOutput": false,
  "trackChanges": true,
  "extractProducts": true,
  "extractVelocity": true,
  "extractCollections": true,
  "extractSitemap": true,
  "extractTraffic": true,
  "extractRevenueEstimate": true,
  "extractTechStack": true,
  "extractSocials": true,
  "extractContact": true,
  "deepContactCrawl": true,
  "extractShopifyMeta": true,
  "extractInternational": true,
  "extractReviewsAggregate": true,
  "extractPromo": true,
  "extractPolicyDetails": false,
  "extractBrandAge": false,
  "extractDerivedSignals": true,
  "generateComparison": true,
  "maxConcurrency": 5,
  "timeout": 20
}
```

# Actor output Schema

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

No description

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

No description

## `errors` (type: `string`):

No description

## `failedStores` (type: `string`):

No description

## `comparisonReport` (type: `string`):

No description

## `discoverySummary` (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 = {
    "seedStoreUrl": "https://allbirds.com",
    "searchTerms": [
        "organic coffee"
    ],
    "storeUrls": [
        "https://allbirds.com"
    ]
};

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

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

```

## MCP server setup

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