# Shopify Store Finder — Discover & Verify Stores by Niche (`insight.solutions/shopify-store-finder`) Actor

Which Shopify stores sell candles, skincare or dog gear? Search the open web by niche and country, verify every candidate against the store's own meta.json and products.json, and get product count, currency, country, price range and sample products per store. No key.

- **URL**: https://apify.com/insight.solutions/shopify-store-finder.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** E-commerce, Lead generation, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 verified shopify stores

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Shopify Store Finder — Discover & Verify Stores by Niche

**Which Shopify stores sell candles, organic skincare or dog accessories — in the US, in Germany, anywhere?** Give this Actor a list of niches and get back one row per **verified** Shopify store: its domain and `*.myshopify.com` handle, name, city and country, currency, how many products and collections it publishes, the countries it ships to, a price range and a sample of its newest products. Optionally its theme, the apps it loads and its social profiles. JSON, CSV or Excel.

Every candidate is **verified against the store's own Shopify storefront** — `meta.json`, then `products.json`, then the page's own Shopify markers — not looked up in a database. A domain that turns out not to be Shopify costs nothing. **$5.00 per 1,000 verified stores** on the FREE tier, plus $0.001 per run. HTTP only: no browser, no login, no API key.

**Company-level data only.** A store row is what the store publishes about itself as a business. No e-mail addresses, no phone numbers, no people.

Found a store? Pull its whole catalogue with [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api), or watch it for price drops, restocks and new products with [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — both take the `domain` this Actor returns.

### Try it in 30 seconds

This is the Store prefill; paste it and run:

```json
{ "queries": ["candles", "organic skincare", "dog accessories"], "maxStoresPerQuery": 20, "sampleSize": 5 }
```

Three niches, up to 20 verified stores each, five sample products per store. The search runs through DuckDuckGo on Apify's datacenter proxy; a live run is expected to return **at least 25 verified stores in under two minutes**. In our offline test suite — the real DuckDuckGo results for `candles site:myshopify.com` from a live run on 2026-11-03, plus synthetic result pages for the other two niches — it returns 45 stores for **$0.226**.

If DuckDuckGo challenges the run's datacenter address (it sometimes answers with an image CAPTCHA, which this Actor never tries to solve), the run still finishes **SUCCEEDED**: it verifies any `domains` you gave, asks Bing the one plain-text search Bing can answer, and writes a free `search-blocked` row saying so.

US stores only, with theme, apps and socials:

```json
{ "queries": ["yoga apparel", "home fragrance", "specialty coffee"], "country": "US", "countries": ["US"], "includeTech": true }
```

Verify a list you already have (no search at all):

```json
{ "domains": ["allbirds.com", "https://www.brooklinen.com/", "farnacandles.myshopify.com", "nike.com"] }
```

**From code** — `client.actor("insight.solutions/shopify-store-finder").call(run_input={"queries": ["candles"]})` with `apify-client`, or `POST https://api.apify.com/v2/acts/insight.solutions~shopify-store-finder/run-sync-get-dataset-items`.

### What comes back

A **store** row (Allbirds, verified offline against its captured `meta.json` and `products.json`; `sampleSize: 2`, null columns cut):

```json
{
  "ok": true,
  "rowType": "store",
  "domain": "allbirds.com",
  "url": "https://www.allbirds.com",
  "myshopifyDomain": "weareallbirds.myshopify.com",
  "shopId": 11044168,
  "name": "Allbirds",
  "description": "The world’s most comfortable shoes, made with natural materials like merino wool, eucalyptus tree fiber, and sugar cane, Allbirds has created the comfiest shoes on the planet.",
  "status": "open",
  "country": "US",
  "province": "California",
  "city": "Beverly Hills",
  "currency": "USD",
  "moneyFormat": "${{amount}}",
  "shipsToCountries": ["US"],
  "shipsToCountryCount": 1,
  "productCount": 338,
  "collectionCount": 1346,
  "shopPayEnabled": true,
  "offersShopPayInstallments": true,
  "sampleProducts": [
    {
      "title": "Men's Cruiser - Buoy Yellow (Natural White Sole)",
      "handle": "mens-cruiser-buoy-yellow-natural-white-sole",
      "url": "https://www.allbirds.com/products/mens-cruiser-buoy-yellow-natural-white-sole",
      "vendor": "Allbirds",
      "productType": "Shoes",
      "priceMin": 120,
      "priceMax": 120,
      "available": true,
      "image": "https://cdn.shopify.com/s/files/1/1104/4168/files/A12825M090-BUOY_YELLOW_SIDE_TRANSPARENT.png?v=1793735209",
      "publishedAt": "2026-11-03T11:48:32-08:00",
      "createdAt": "2026-02-04T17:03:24-08:00"
    },
    { "title": "Women's Allbirds Flip Flop - Dusty Pink", "priceMin": 50, "priceMax": 50, "…": "…" }
  ],
  "priceRange": { "min": 50, "max": 120, "currency": "USD" },
  "topVendors": ["Allbirds"],
  "topProductTypes": ["Shoes"],
  "newestProductAt": "2026-11-03T11:48:32-08:00",
  "verifiedBy": "meta.json",
  "foundVia": { "query": null, "engine": null, "position": 1, "kind": "input", "rung": null, "sourceUrl": "allbirds.com" }
}
```

A store found by search carries where it was found: `"foundVia": { "query": "candles site:myshopify.com", "engine": "duckduckgo", "position": 3, "kind": "serp", "rung": "site", "sourceUrl": "https://farnacandles.myshopify.com/collections/all" }`.

With `includeTech: true` the same row adds (from Allbirds' captured home page):

```json
{
  "theme": { "name": "[DNAM Theme July 2026]", "id": 130450260048, "themeStoreId": null, "schemaName": "allbirds-theme" },
  "apps": ["Google Tag Manager", "Shop Pay", "Attentive", "Triple Whale", "Elevar", "Redo"],
  "socials": { "instagram": "https://www.instagram.com/allbirds", "facebook": "https://www.facebook.com/weareallbirds", "tiktok": "https://www.tiktok.com/@weareallbirds", "pinterest": "https://www.pinterest.com/weareallbirds", "youtube": "https://www.youtube.com/channel/UCnGErLCau5qNJ0Xwe6uEyTw", "x": "https://x.com/allbirds" },
  "hasBlog": true,
  "locale": "en-US"
}
```

A store whose `meta.json` and `products.json` are switched off — Gymshark's headless storefront answers 404 and 403 — is still verified, from its own page: `"verifiedBy": "html-markers"`, `"evidence": "Shopify markers: cdn.shopify.com"`, `"myshopifyDomain": "gymsharkusa.myshopify.com"`, and nulls where `meta.json` would have answered.

A candidate that is not Shopify is a free **diagnostic** row:

```json
{ "rowType": "diagnostic", "errorType": "not-shopify", "domain": "nike.com", "error": "nike.com answered, and not as a Shopify store. Not charged.", "evidence": "meta.json: HTTP 404; products.json: HTTP 404; home page: HTTP 200" }
```

The last row of every run is a free **summary**: queries run, SERP pages read, candidates, verified, not-shopify, unreachable, duplicates, stores filtered out, and counts by country, currency, verification method and query.

### Use cases

- **Agencies and Shopify app vendors prospecting by niche** — every candle, coffee or pet store the open web knows about, with its size (`productCount`), its market (`country`, `currency`, `shipsToCountries`) and, with `includeTech`, the apps it already runs and the theme it is on.
- **Suppliers and wholesalers looking for retailers** — stores that carry your category, sized and located, with a sample of what they sell and at what prices.
- **Market and category analysts** — how many independent stores sell a niche, in which countries and currencies, at which price points, from one run per niche.
- **Competitive research** — the stores that rank for your category, verified, with their catalogue size and newest product date, ready to hand to [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) for the full catalogue.
- **Cleaning a list** — paste 5,000 domains into `domains`: the Shopify ones come back as rows with their facts, the rest as free `not-shopify` rows.

### How it compares

- **Verified against the storefront, not a database.** Every row is a store that answered as a Shopify store on the day of the run, and its numbers are the store's own — not a snapshot from a crawl months ago.
- **Pay for stores, not for guesses.** Candidates that are not Shopify, sites that cannot be reached and stores below your `minProducts` are free rows. Only a verified store is a paid row.
- **Real numbers on every row.** Product and collection counts, currency, country, ship-to countries, a price range and sample products — enough to qualify a store without opening it.
- **One run from niche to list.** Search, listicle expansion, verification, filters and dedupe in one Actor; no export from one tool into another.
- **No login, no key, no browser.** Public search pages and public storefront endpoints, read over plain HTTP.

### How stores are found and verified

**1. Search, per niche, cheapest and best first.** Each niche walks a fixed ladder of searches, page by page, and stops as soon as it has `maxStoresPerQuery` verified stores:

| Rung | Query | Engine |
|---|---|---|
| `site` | `candles site:myshopify.com` | DuckDuckGo |
| `country` (only with `country`) | `candles shop United States site:myshopify.com` | DuckDuckGo |
| `inurl` | `candles inurl:myshopify.com` | DuckDuckGo |
| `powered-by` | `"candles" "powered by shopify"` | DuckDuckGo; Bing only when DuckDuckGo refuses the run |

DuckDuckGo honours `site:` — a live run on 2026-11-03 returned ten real `*.myshopify.com` candle stores from a datacenter address — and Bing does not (its answer to the same query was Amazon, Walmart, Target and big brands), so Bing is never asked an operator query. DuckDuckGo's no-JavaScript endpoints are read through the run's proxy (Apify datacenter by default), one proxy session per search, at least **2 seconds** between two requests on one exit and at most six per exit. A second page is asked for only after the first page's candidates are verified, and only with the values in the page's own *Next* form; a search stops at `maxSerpPagesPerQuery` pages, at an empty page, or at a page that adds nothing new. On the plain-text rung, a page whose results do not mention the niche is a decoy and nothing on it is verified.

**When DuckDuckGo refuses.** DuckDuckGo answers some datacenter addresses with an image CAPTCHA (HTTP 202). The challenge is recognised, the search is retried once from a fresh exit and once on DuckDuckGo's lite endpoint, and then DuckDuckGo is **not asked again for the rest of the run** — never a loop, never a CAPTCHA solver. The operator rungs cannot run without it; the plain-text rung goes to Bing (direct, one page); `domains` are verified as usual; and one free `search-blocked` row explains what happened.

**2. The host filter.** DuckDuckGo's ad rows are dropped, and so are marketplaces, social networks, directories, review sites, app stores, search engines and Shopify's own corporate and help sites (`shopify.com`, `apps.shopify.com`, `help.shopify.com`) — `*.myshopify.com` stores are always kept. One candidate per registrable domain.

**3. Listicles.** A result that is an article *about* stores — "12 best organic skincare Shopify stores", "16 places to buy candles in NYC" — is read for its outbound links (with `expandListicles`, the default): at most **50 outbound links** per page and 3 listicles per niche, the page's `robots.txt` honoured, aggregators dropped. Each linked site is a candidate with `foundVia.kind: "listicle"`.

**4. Verification — at most three requests per candidate, one at a time per domain:**

1. `GET /meta.json` — Shopify's storefront summary (about 1 KB). JSON with `myshopify_domain` is a verified store (`verifiedBy: "meta.json"`) and gives the shop id, name, description, city, province, country, currency, money format, product and collection counts, ship-to countries and Shop Pay facts. A redirect to `/password` is a **password-protected** store: verified, `status: "password-protected"`, no product sample.
2. `GET /products.json?limit=<sampleSize>` — the sample (and the proof, `verifiedBy: "products.json"`, when `meta.json` did not answer).
3. The home page — only when both failed, or with `includeTech` — read for Shopify's own markers (`cdn.shopify.com`, `Shopify.theme`, `shopify-section`, the `X-ShopId` header …; `verifiedBy: "html-markers"`) and, with `includeTech`, the theme, apps, socials, blog and locale.

Nothing Shopify-shaped answers: a free `not-shopify` row with what each request returned. A bot wall on `meta.json` or the home page — an HTTP 429, a Vercel, Cloudflare or CloudFront interstitial — is a free `unreachable` row, never `not-shopify` (the wall says nothing about what is behind it), and it is never retried or worked around. A 403 on `products.json` alone is not a wall: headless storefronts refuse that one path, so the home page is still asked. A `myshopify.com` handle no store owns (`{"errors":"Not Found"}`) is `not-shopify` after one request.

**5. Dedupe, filters, caps.** A candidate whose registrable domain was already taken is skipped before any request; a verified store whose `myshopify_domain` was already returned is skipped too (a custom domain and its myshopify host are one store, billed once). Then `minProducts`, `countries` and `currencies` are applied, and `maxStores` caps the run.

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `queries` | array | — (prefill: `candles`, `organic skincare`, `dog accessories`) | Niches or keywords, one per line. Each walks the search ladder above. Up to 200. |
| `domains` | array | `[]` | Stores to verify with no search: a domain, any URL on the site, or a `*.myshopify.com` host. Up to 5,000. |
| `country` | string | `""` | Two-letter code. Regionalises the search (DuckDuckGo region, Bing market) and adds the `country` rung. Not a filter — see `countries`. |
| `language` | string | `en` | Bing's interface language; with no `country`, `en` uses DuckDuckGo's US-English region and any other language lets DuckDuckGo choose. |
| `maxStores` | integer | 200 | The run stops at this many verified stores (1–5,000). |
| `maxStoresPerQuery` | integer | 50 (prefill 20) | A niche stops at this many verified stores (1–500). Candidates are verified in batches no larger than what the niche still needs. |
| `maxSerpPagesPerQuery` | integer | 3 | DuckDuckGo result pages per search (1–10). |
| `expandListicles` | boolean | `true` | Read "best stores" articles for their outbound links. |
| `minProducts` | integer | 1 | Stores publishing fewer products are a free `below-min-products` row. 0 keeps all. A store verified by markers alone (no count) is kept. |
| `includeSampleProducts` | boolean | `true` | Read `products.json` for the sample, price range, top vendors and types. Off: one request fewer per store. |
| `sampleSize` | integer | 5 | Products sampled per store (1–50). |
| `includeTech` | boolean | `false` | Also read the home page: theme, apps (a table of 46), socials, blog, locale. One request more per store. |
| `countries` | array | `[]` | Keep only stores whose `meta.json` country is listed. A store that does not say is not a match. |
| `currencies` | array | `[]` | Keep only stores whose shop currency is listed. |
| `maxConcurrency` | integer | 8 | Stores verified in parallel (1–20). One store is never asked two things at once. |
| `maxRunSecs` | integer | 240 | Wall-clock budget (30–3,600). Everything written before it is kept and billed; one free `timeout` row says what was not reached. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | DuckDuckGo, the stores and listicle pages go through it (Apify datacenter is all they need). Bing goes direct. |

A run with nothing usable — no niche and no domain, an unknown `country`, a malformed `countries` or `currencies` code, more than 200 queries or 5,000 domains — finishes **FAILED** before a single request, with a free `invalid-input` row saying why. A single `domains` line that is not a domain is a free `invalid-input` row and the rest of the run carries on.

### Output reference

Every row has the same columns, `null` where a column does not apply, so the dataset exports as one table. `rowType` is `store`, `diagnostic` or `summary`.

**Store rows** (paid, one per verified store): `ok`, `rowType`, `domain` (primary domain, no `www.`), `url`, `myshopifyDomain`, `shopId`, `name`, `description` (≤ 500 characters, e-mail addresses and phone numbers removed), `status` (`open` · `password-protected`), `country`, `province`, `city`, `currency`, `moneyFormat`, `shipsToCountries[]` (`*` is Shopify's rest-of-world zone), `shipsToCountryCount` (`*` not counted), `productCount`, `collectionCount`, `shopPayEnabled`, `offersShopPayInstallments`, `verifiedBy` (`meta.json` · `products.json` · `html-markers`), `foundVia{query, engine, position, kind, rung, sourceUrl}` (`kind`: `serp` · `listicle` · `input`), `evidence` (on an `html-markers` row, the markers it rests on), `scrapedAt`.

**From the sample** (`includeSampleProducts`): `sampleProducts[]` — `title`, `handle`, `url`, `vendor`, `productType`, `priceMin`, `priceMax`, `available` (any variant), `image`, `publishedAt`, `createdAt` — and `priceRange{min, max, currency}`, `topVendors[]`, `topProductTypes[]`, `newestProductAt`.

**With `includeTech`:** `theme{name, id, themeStoreId, schemaName}`, `apps[]`, `socials{}` (the store's own profile URLs: `instagram`, `facebook`, `tiktok`, `pinterest`, `youtube`, `x`), `hasBlog`, `locale`.

**Diagnostic rows** (free): `errorType`, `error`, `evidence`, and `domain`, `url`, `foundVia` where they apply. The types:

| `errorType` | What it means |
|---|---|
| `not-shopify` | The candidate answered, and not as a Shopify store. `evidence` lists what each request returned. |
| `unreachable` | Refused (HTTP 429, a bot-protection page) or unreachable. Says nothing about whether it is Shopify; not retried. |
| `below-min-products` | A Shopify store below your `minProducts`. |
| `search-blocked` | DuckDuckGo challenged the run and was not asked again; what still ran is in the message. |
| `timeout` | `maxRunSecs` ran out. Everything before it was kept. |
| `invalid-input` | A field or a `domains` line that could not be used. |

**The summary row** (free, last): `summary` — `queriesRun`, `rungsRun`, `serpPages`, `domainsGiven`, `candidates`, `verified`, `notShopify`, `unreachable`, `belowMinProducts`, `duplicates`, `filteredOut{country, currency}`, `listiclesExpanded`, `adsDropped`, `aggregatorsDropped`, `searchBlocked`, `byCountry`, `byCurrency`, `byVerifiedBy`, `byQuery`, `requests`, `budgetStopped`, `maxStoresReached`, `deadlineHit`, `statusMessage`.

### Pricing

| Event | What it is | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| **`store`** | One verified Shopify store returned | **$0.005** | **$0.005** | **$0.004** | **$0.003** |
| `actor-start` | Once per run, only after the first store | $0.001 | $0.001 | $0.001 | $0.001 |

**$5.00 per 1,000 verified stores.**

| Run | Cost |
|---|---|
| The prefill as the offline test suite runs it — 45 verified stores | **$0.226** |
| The prefill live at its expected minimum — 25 stores | **$0.126** |
| `maxStores: 1000` across a few dozen niches | **$5.00** (+ $0.001) |
| The same at GOLD | **$3.00** (+ $0.001) |
| 5,000 domains to clean, 1,200 of them Shopify | **$6.00** — the other 3,800 rows are free |
| A run where nothing verifies | **$0.00**, SUCCEEDED |

Charging is charge-after-push: a store row is in your dataset before its event is recorded, and it is pushed only when the remaining `ACTOR_MAX_TOTAL_CHARGE_USD` covers it, so a run never bills past your ceiling — it stops verifying, finishes SUCCEEDED and says so. Never charged: candidates that are not Shopify, unreachable ones, stores below `minProducts` or outside `countries` / `currencies`, duplicates, diagnostics, the summary row, and a run that returns no store (start fee included).

### Limits

- **Search engines rank what they rank.** The stores you get are the ones DuckDuckGo returns for the niche, a few pages deep; it is not a census of every Shopify store, and a store with no search footprint is not found. More niches, synonyms and `country` find more.
- **DuckDuckGo may refuse a datacenter address.** Then the operator searches cannot run for the rest of that run (Bing ignores `site:` and `inurl:`), and the run returns what `domains`, Bing's plain-text answer and listicles give, with a free `search-blocked` row. Run again later, or pass known domains.
- **Password-protected stores** are verified and returned with `status: "password-protected"`, but have no product sample.
- **`meta.json` can be switched off** by a store, or answered by a headless front end. Such a store is still verified by `products.json` or by its page's markers, with nulls for the `meta.json` fields — and with `minProducts`, a store with no known count is kept.
- **Filters read the store's own word.** `countries` is the country the store gives in `meta.json`, not where it ships or where its customers are.
- **Apps are what the home page loads**, matched against a table of 46. An app that loads only on product pages, only after consent, or is not in the table is not listed.
- **Per run:** up to 200 queries or 5,000 domains, at most three requests per candidate store, at most 50 outbound links per listicle and 3 listicles per niche, `maxSerpPagesPerQuery` result pages per search.
- Not affiliated with Shopify, DuckDuckGo, Microsoft Bing, or any store named in the output. Names are used descriptively.

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions** and **pay-per-event** pricing, so it works over the Apify MCP server (`mcp.apify.com`) and with agentic (x402) payments. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery, and Apify Schedules run it unattended — a weekly run per niche, deduplicated on `myshopifyDomain`, is a list of new stores.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~shopify-store-finder/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["candles","soy wax melts"],"maxStoresPerQuery":20,"countries":["US"]}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/shopify-store-finder").call(run_input={
    "queries": ["organic skincare", "clean beauty"],
    "country": "GB",
    "countries": ["GB"],
    "minProducts": 20,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] == "store":
        print(row["domain"], row["name"], row["productCount"], row["currency"], row["priceRange"], sep=" | ")
```

**Building an app with Lovable?** Apify's Lovable connector runs any Actor from inside a Lovable project with your Apify token. Connect Apify in Lovable once, then ask it: *"Use Apify to run insight.solutions/shopify-store-finder for my niche and build a prospect list around the results."* A run of a few niches finishes well inside Lovable's 300-second synchronous limit at the default settings, and every result is one JSON object per row, so the generated app needs no extra parsing. Usage bills to the Apify account whose token is connected.

### FAQ

**How is a store "verified"?**
It answered as a Shopify store on the day of the run: its `meta.json` named its `myshopify_domain`, or its `products.json` returned products, or its own page carried Shopify's markers. `verifiedBy` says which.

**Why fewer stores than `maxStoresPerQuery`?**
The search ran out first — DuckDuckGo returned fewer stores for that niche across the ladder's pages — or candidates were not Shopify, or `minProducts`, `countries` or `currencies` removed them. The summary row counts each.

**Why did a store I know is on Shopify come back `not-shopify` or `unreachable`?**
`unreachable` is a refusal (a 429 or a bot-protection page): it says nothing about the platform and is never billed. `not-shopify` means none of the three requests answered like Shopify — a store behind a fully custom headless front end can look like that.

**Can I get the stores' e-mail addresses?**
No — this Actor is company-level and returns no contact details. For a business's published contact channels, see [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) or [Company Contact Finder](https://apify.com/insight.solutions/company-contact-finder).

**Is a `*.myshopify.com` result the store's real address?**
It is its permanent Shopify handle. `domain` and `url` are the custom domain the store gives in `meta.json` when it has one; the handle stays in `myshopifyDomain`.

**What do I do with the list?**
Hand the `domain` to [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) for the full catalogue, or to [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) to watch it for price drops, restocks and new products.

### Legal and data-protection notes

- **Public sources only.** DuckDuckGo's and Bing's public result pages, and each store's public storefront endpoints (`meta.json`, `products.json`, its home page) that Shopify serves to every anonymous visitor. It never logs in, never supplies cookies or credentials, never enters a store password, and never solves or bypasses a CAPTCHA or a bot wall: a refusal is recorded as a free row and left alone. Listicle pages are read only where their `robots.txt` allows it.
- **Companies, not people.** A row describes a store as a business — its name, location, currency and products, as the store itself publishes them. No e-mail address, phone number or person is extracted; any that a merchant typed into the shop description or a product title is removed before the row is written. `socials` holds the store's own brand profiles.
- **No profiling of individuals.** There is no person search and no input that names a person.
- **We are not a data broker.** This Actor holds no database and sells no list. It searches and checks public pages on demand and writes the result to *your* dataset on *your* account.
- **Not affiliated with, endorsed by or sponsored by** Shopify, DuckDuckGo, Microsoft, or any store named. Names and trademarks are used descriptively.
- **You are responsible for how you use the output**, including any outreach to the stores it names, under the GDPR, the CCPA, ePrivacy, CAN-SPAM and other applicable law.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Sponsor & Advertiser Finder — YouTube, Podcasts & Newsletters](https://apify.com/insight.solutions/sponsorship-intelligence-api) — which brands sponsor which YouTube channels, podcasts and Substack newsletters, with promo codes, offers and sponsor links, company-level only.
- [Google Ads Transparency API — Advertisers, Ads & Creatives](https://apify.com/insight.solutions/google-ads-transparency-api) — every ad a verified advertiser runs on Google, from the Ads Transparency Center, by brand name, AR id or domain: format, first and last shown, days shown and preview links, individuals excluded.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Repos, Trending & Releases API](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Posts & Pages API](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata API](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder API](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Company Contact Finder](https://apify.com/insight.solutions/company-contact-finder) — company names in, each one's verified website with its business emails, phone numbers and social profiles out.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Litigation Signals API — Lawsuits, Settlements & Investigations](https://apify.com/insight.solutions/litigation-signals-api) — lawsuits, settlements and investigations per public company from SEC 10-K, 10-Q and 8-K disclosures, press wires and SEC, FTC and DOJ notices, company-level only.
- [Funding Signals API — Rounds from SEC Form D, Wires & News](https://apify.com/insight.solutions/funding-signals-api) — who just raised money: one row per funding round from SEC Form D filings, press wires and Google News, with amount, round, investors, industry and state, company-level only.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs API](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Careers Page Jobs API — Open Roles from Any Company's Site](https://apify.com/insight.solutions/careers-page-jobs-api) — open roles from any company's own careers site: domain in, the platform recognised (Eightfold, Phenom, Jibe, iCIMS, Google, Amazon, 14 ATSs) or the site's structured data read, one row per job.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products API](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Price Tracker API — Prices, Stock & Changes from Any Retailer](https://apify.com/insight.solutions/price-tracker-api) — price, stock, list price and discount from any product URL, read from the page's structured data, with price-drop and restock rows between runs.
- [Shopify App Store API](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events API](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

## `queries` (type: `array`):

What the stores sell, one niche or keyword per line: `candles`, `organic skincare`, `dog accessories`. Each niche is searched down a fixed ladder — `<niche> site:myshopify.com`, then (with a country) `<niche> shop <country> site:myshopify.com`, then `<niche> inurl:myshopify.com`, then `"<niche>" "powered by shopify"` — page by page, until it has `maxStoresPerQuery` verified stores or the results run out. Up to 200 niches per run.

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

Optional: domains to check directly, one per line — a bare domain (`allbirds.com`), any URL on the site, or a `*.myshopify.com` host. Each is verified exactly like a search candidate, with no search. Up to 5,000 per run; a line that is not a domain is a free `invalid-input` row and the rest of the run carries on.

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

Optional two-letter country code (`US`, `GB`, `DE`, `AU` …). It regionalises the search (DuckDuckGo's region, Bing's market) and adds the `<niche> shop <country name> site:myshopify.com` rung. It does not filter results by itself — use `countries` for that. Empty: DuckDuckGo's US-English region.

## `language` (type: `string`):

Two-letter language code for Bing's interface language and, with no country set, whether the US-English DuckDuckGo region is used (`en`) or DuckDuckGo picks a region itself (any other language).

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

The run stops once this many verified stores are in the dataset (each is one paid `store` row). 1–5,000.

## `maxStoresPerQuery` (type: `integer`):

A niche stops searching as soon as it has this many verified stores; candidates are verified in batches no larger than what the niche still needs, so nothing is verified that could not be returned. 1–500.

## `maxSerpPagesPerQuery` (type: `integer`):

How many DuckDuckGo result pages each search of the ladder may read (page 2 onward follows the page's own Next form). A search also stops on a page that adds nothing new. 1–10.

## `expandListicles` (type: `boolean`):

A result that is an article about stores ("12 best organic skincare Shopify stores", "places to buy candles in NYC") is read for its outbound links — at most 50 per page, 3 pages per niche, robots.txt honoured — and each linked site is verified as a candidate (`foundVia.kind: listicle`).

## `minProducts` (type: `integer`):

Verified stores with fewer published products than this are not returned (a free `below-min-products` row instead). The count is the store's own `published_products_count`; a store verified without it (markers only) is kept. 0 keeps every store.

## `includeSampleProducts` (type: `boolean`):

Read `products.json?limit=<sampleSize>` for every verified store: `sampleProducts[]`, `priceRange`, `topVendors`, `topProductTypes`, `newestProductAt`. Off saves one request per store.

## `sampleSize` (type: `integer`):

How many of the store's newest products are sampled. 1–50.

## `includeTech` (type: `boolean`):

Also read each store's home page (one more request per store) for its Shopify theme, the apps it loads (from a table of 46: reviews, email/SMS, subscriptions, loyalty, BNPL, page builders, analytics pixels …), its own social profiles, whether it has a blog, and its locale.

## `countries` (type: `array`):

Optional filter: two-letter codes (`US`, `GB` …) matched against the country the store gives in its own `meta.json`. A store that does not say is not a match. Filtered stores are free and counted in the summary.

## `currencies` (type: `array`):

Optional filter: three-letter codes (`USD`, `EUR`, `GBP` …) matched against the store's own shop currency. Filtered stores are free and counted in the summary.

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

How many candidate stores are verified at once. One store is never asked two things at the same time, whatever this is set to. 1–20.

## `maxRunSecs` (type: `integer`):

Wall-clock budget for the whole run. When it is reached the Actor stops searching and verifying, keeps — and bills — every store it already wrote, and files one free `timeout` row. 30–3,600.

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

Used for DuckDuckGo, the store endpoints and listicle pages; Apify datacenter by default, which is all they need. Bing, asked only when DuckDuckGo refuses the run, goes out directly.

## Actor input object example

```json
{
  "queries": [
    "candles",
    "organic skincare",
    "dog accessories"
  ],
  "domains": [
    "allbirds.com",
    "https://www.brooklinen.com/",
    "farnacandles.myshopify.com"
  ],
  "country": "",
  "language": "en",
  "maxStores": 200,
  "maxStoresPerQuery": 20,
  "maxSerpPagesPerQuery": 3,
  "expandListicles": true,
  "minProducts": 1,
  "includeSampleProducts": true,
  "sampleSize": 5,
  "includeTech": false,
  "countries": [],
  "currencies": [],
  "maxConcurrency": 8,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Verified Shopify stores in one schema, plus diagnostic rows and a run summary. Delivered as JSON items in the default dataset.

# 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 = {
    "queries": [
        "candles",
        "organic skincare",
        "dog accessories"
    ],
    "maxStoresPerQuery": 20,
    "sampleSize": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/shopify-store-finder").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 = {
    "queries": [
        "candles",
        "organic skincare",
        "dog accessories",
    ],
    "maxStoresPerQuery": 20,
    "sampleSize": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/shopify-store-finder").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 '{
  "queries": [
    "candles",
    "organic skincare",
    "dog accessories"
  ],
  "maxStoresPerQuery": 20,
  "sampleSize": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/shopify-store-finder --silent --output-dataset

```

## MCP server setup

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

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/W4GI27h5B3AzzySX2/builds/oajF0B1dnopAL7fk7/openapi.json