Pricing

from $4.75 / 1,000 stores

Try for free

Go to Apify Store

Shopify Theme Detector - Find Stores by Theme in Bulk

Try for free

Find out which theme a Shopify store runs, in bulk. Every record you are charged for returns the theme family and its Theme Store ID where it has one, alongside store size and country - so you can prospect owners of a rival theme or of an ageing free one.

Pricing

from $4.75 / 1,000 stores

Rating

0.0

(0)

Developer

Blackcube

Actor stats

Bookmarked

Total users

Monthly active users

8 hours ago

Last modified

Categories

Lead generation

E-commerce

Developer tools

You can access the Shopify Theme Detector - Find Stores by Theme in Bulk programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "1.0",
    "x-build-id": "JZlvvH10ox0ake6Z7"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/vonsensey~shopify-theme-detector-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-vonsensey-shopify-theme-detector-scraper",
        "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/vonsensey~shopify-theme-detector-scraper/runs": {
      "post": {
        "operationId": "runs-sync-vonsensey-shopify-theme-detector-scraper",
        "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/vonsensey~shopify-theme-detector-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-vonsensey-shopify-theme-detector-scraper",
        "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",
        "properties": {
          "storeUrls": {
            "title": "Store URLs",
            "type": "array",
            "description": "Shopify stores to qualify, one per line. Accepts a bare domain (example.com), a full URL, or a myshopify handle (brand.myshopify.com). Leave empty to let discovery find stores instead.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "discoverStores": {
            "title": "Discover new stores",
            "type": "boolean",
            "description": "Also find Shopify stores automatically, instead of only qualifying the ones you supply. With keywords set below, discovery first searches Shop (Shopify's shopping app) for stores selling them; without keywords it is broad, so narrow it with the filters below. Stores that fail your filters are never charged.",
            "default": true
          },
          "maxStores": {
            "title": "Max stores to deliver",
            "minimum": 1,
            "maximum": 100000,
            "type": "integer",
            "description": "How many qualified store records to return. This is what you pay for — one charge per delivered store.",
            "default": 50
          },
          "maxStoresScanned": {
            "title": "Max stores to check",
            "minimum": 1,
            "maximum": 100000,
            "type": "integer",
            "description": "Ceiling on how many candidates are checked while looking for matches. Raise it when a narrow filter (a small country, a rare keyword) rejects most candidates. Checking is free; only delivered stores are charged.",
            "default": 200
          },
          "discoverySeed": {
            "title": "Discovery seed",
            "minimum": 1,
            "type": "integer",
            "description": "Pin this to get the same discovered stores every run — useful for reproducible tests. Leave empty and each run samples a different slice, so repeat runs bring back new stores instead of the ones you already paid for."
          },
          "ccIndex": {
            "title": "Crawl index (advanced)",
            "type": "string",
            "description": "Pin discovery to one specific web-crawl index, e.g. CC-MAIN-2026-30. Leave empty to draw from the most recent indexes automatically, which is what you want unless you are reproducing an old run."
          },
          "countries": {
            "title": "Countries",
            "type": "array",
            "description": "Only deliver stores based in these countries. Two-letter ISO codes, e.g. US, GB, AU, CA, DE.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "minProducts": {
            "title": "Min products",
            "minimum": 0,
            "type": "integer",
            "description": "Only deliver stores with at least this many published products. Filters out empty and abandoned stores."
          },
          "maxProducts": {
            "title": "Max products",
            "minimum": 0,
            "type": "integer",
            "description": "Only deliver stores with at most this many published products. Useful for targeting small independent brands rather than large retailers."
          },
          "activeWithinDays": {
            "title": "Active within (days)",
            "minimum": 1,
            "type": "integer",
            "description": "Only deliver stores that published a product in the last N days. The strongest signal that a store is still trading. Reads the catalogue, so it turns 'Include catalogue' on automatically."
          },
          "launchedWithinDays": {
            "title": "Launched within (days)",
            "minimum": 1,
            "type": "integer",
            "description": "Only deliver stores that look recently launched, judged by the oldest product they ever published. Turns on the launch-era lookup automatically (one extra request per store). Stores whose catalogue is too large to page to the end are excluded rather than guessed at."
          },
          "keywords": {
            "title": "Must match keywords",
            "type": "array",
            "description": "Only deliver stores whose name, description, domain, vendors or product types contain at least one of these words. With discovery on, each keyword is also searched on Shop (up to 10 result pages; 40-100 candidate stores a keyword in our October 2026 tests), and a store found that way counts as a match.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "excludeKeywords": {
            "title": "Exclude keywords",
            "type": "array",
            "description": "Never deliver stores matching any of these words.",
            "default": [],
            "items": {
              "type": "string"
            }
          },
          "includeCatalog": {
            "title": "Include catalogue",
            "type": "boolean",
            "description": "Adds the last-product date (is this store still active?), price range, vendors and product types. Costs one extra request per store.",
            "default": false
          },
          "includeContacts": {
            "title": "Include contact details",
            "type": "boolean",
            "description": "Adds the store's public contact email, phone and social profiles, taken from the storefront and its published policy pages.",
            "default": false
          },
          "includeTechStack": {
            "title": "Include theme and apps",
            "type": "boolean",
            "description": "Adds the Shopify theme and the apps detected on the storefront — useful for targeting stores that already run (or lack) a given tool.",
            "default": true
          },
          "includeLaunchDate": {
            "title": "Include launch-era estimate",
            "type": "boolean",
            "description": "Adds the oldest published product date as a rough store-age signal. Off by default because it costs one extra request per store.",
            "default": false
          },
          "maxCostUsd": {
            "title": "Max cost (USD)",
            "minimum": 0.01,
            "type": "number",
            "description": "Hard ceiling on what this run may cost, in USD. The run stops cleanly once delivering another store would exceed it. Accepts fractions, e.g. 0.25. Leave empty for no ceiling."
          },
          "maxConcurrency": {
            "title": "Concurrency",
            "minimum": 1,
            "maximum": 30,
            "type": "integer",
            "description": "Parallel stores in flight. Higher is faster; the default is tuned to stay well inside Shopify's rate limits.",
            "default": 10
          },
          "proxyConfiguration": {
            "title": "Proxy",
            "type": "object",
            "description": "Keep Apify Proxy on (it is selected by default): Shopify rate-limits by IP, and a store it refuses comes back as a free error row. Residential is not needed, and the proxy cost is included in the per-store price."
          }
        }
      },
      "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Shopify Theme Detector | Check Store Themes in Bulk OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Shopify Theme Detector - Find Stores by Theme in Bulk from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Shopify Theme Detector - Find Stores by Theme in Bulk API in Python

Shopify Theme Detector - Find Stores by Theme in Bulk API in JavaScript

Shopify Theme Detector - Find Stores by Theme in Bulk API through CLI

Shopify Theme Detector - Find Stores by Theme in Bulk API

Shopify Store Intelligence - Products, Leads, Tech & Revenue

inexhaustible_glass/shopify-store-intelligence

All-in-one Shopify scraper: full product catalog + prices, store leads (emails, phone, socials), tech stack & pixels, revenue & store-size estimate, brand signals, and new-product/restock/price monitoring. One tool for dropshippers, DTC brands, agencies & market research. No API key.

Hitman studio

Shopify Store Detector — Tech, Theme & App Detection API

nexgendata/shopify-store-detector

Reverse-engineer any Shopify store: detect theme, 55+ installed apps (Klaviyo, Judge.me, Yotpo, ReCharge), full tech stack & Shopify plan. BuiltWith alternative at 1/100th the cost. Essential for e-commerce agencies, app developers & competitive research.

NexGenData

Shopify Store Finder, Scraper & Analyzer - Find Stores by App

storeinspect/shopify-store-finder

Find Shopify stores by the apps they use or don't use, country, category and traffic. Also a Shopify store analyzer: paste store URLs to get theme, apps, pixels and tech stack. A Shopify store scraper backed by a Shopify store database of 1M+ stores. No API key. Pay per store.

StoreInspect

E-commerce Theme Detector

trovevault/ecommerce-theme-detector

Detect the active theme of any e-commerce store from its HTML. Works on Shopify, WooCommerce, WordPress, Magento, PrestaShop, Shopware, OpenCart, BigCommerce, Wix, and Squarespace. No API keys. No proxies. Bulk detection in seconds.

Trove Vault

Shopify Store Info

pintostudio/shopify-store-info

Get instant Shopify store data from any URL: title, meta description, theme, logo, currency, product & collection counts, emails, phone numbers, social links, shipping countries & Shopify Pay support. Ideal for competitor research, lead generation, and building store directories.

Pinto Studio

130

4.0

(1)

Shopify Store Finder - URLs, emails & more

igolaizola/shopify-store-finder

Shopify Store Finder locates Shopify stores by keyword and returns structured data: ID, title, description, URL, contact emails, earliest page date, and estimated product count range. Perfect for market research, lead generation, and competitor discovery.

Iñigo Garcia Olaizola

542

5.0

(2)

Shopify Store Leads Scraper - Emails, Apps & Store Size

vonsensey/shopify-store-leads-scraper

Find and qualify Shopify stores. Each lead carries the contact email, socials, country, currency, product and collection counts, theme, installed apps, price band, and the date the store last published a product - so you can tell a live brand from a dead one. Pay per store.

Blackcube

Shopify Product Scraper - Products, Collections & Entire Stores

novus/shopify-scraper

An advanced Shopify data extraction tool built for professionals. Simply enter any store, collection, or product URL — the scraper automatically detects Shopify stores, fetches structured product data via the Shopify JSON API, and handles pagination for large catalogs.