# New Shopify Stores Radar & Shopify Checker (Pre-Launch) (`prelaunch-radar/new-shopify-stores-pre-launch-radar`) Actor

New Shopify stores, including pre-launch stores behind a password page, detected from public Certificate Transparency logs, with RDAP registration date, niche, country and catalog counts. Also checks any domain for Shopify. Flat JSON for AI agents and MCP. Zero personal data.

- **URL**: https://apify.com/prelaunch-radar/new-shopify-stores-pre-launch-radar.md
- **Developed by:** [Pre-Launch Radar](https://apify.com/prelaunch-radar) (community)
- **Categories:** E-commerce, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 store delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## New Shopify Stores Radar & Shopify Checker (Pre-Launch)

Find Shopify stores **the day their domain gets its first HTTPS certificate**, including
stores still behind their password page. Most new-store tools only see a shop once it has
public products; this one reads public Certificate Transparency logs, so pre-launch stores
show up too (about 40% of detections).

Built as a **tool for AI agents** as much as for people: one flat JSON object per store,
stable field names, no nested pages to crawl, pay per result.

### What it returns

| Field | Type | Meaning |
|---|---|---|
| `store_domain` | string | Public domain of the store |
| `store_name` | string | null | Storefront name |
| `status` | `live` | `pre-launch` | `pre-launch` = password page, not open yet |
| `niche` | string | One of 16 niches (from public product titles and types), `General store` or `Unknown (no products yet)` |
| `country`, `region`, `currency` | string | null | Store-level settings published by the storefront |
| `products`, `collections` | integer | null | Public catalog counts |
| `ships_to` | integer | null | Number of shipping countries |
| `product_types`, `sample_titles` | string | null | Short public catalog preview |
| `domain_registered` | `YYYY-MM-DD` | null | Registration date from the official RDAP registry |
| `first_detected` | `YYYY-MM-DD` | Day the radar first saw the store (feed mode) |

In **Check my domains** mode each row also has `input`, `is_shopify` (boolean) and
`dns_status`.

Example item (illustrative values):

```json
{
  "store_domain": "example-store.com",
  "store_name": "Example Store",
  "status": "live",
  "niche": "Health & Supplements",
  "country": "GB",
  "region": null,
  "currency": "GBP",
  "products": 12,
  "collections": 3,
  "ships_to": 41,
  "product_types": "Supplements",
  "sample_titles": "Pre-Workout – Watermelon (380g)",
  "domain_registered": "2026-09-20",
  "first_detected": "2026-09-26"
}
```

Business-level data only: **no emails, no phone numbers, no names of people.**

### Modes

- **New stores feed** (`"mode": "feed"`) — stores detected in the last 1–30 days whose domain
  was registered in the last 30 days. Filter by status, niche and country. The feed is
  refreshed up to every 2 hours.
- **Check my domains** (`"mode": "enrich"`) — send domains; get whether each one runs on
  Shopify, its registration date, status, niche and catalog counts. Useful for automated
  lead enrichment and CRM clean-up.

### For AI agents (MCP, API, x402)

- **MCP**: add this Actor as a tool in the Apify MCP server
  (`https://mcp.apify.com/?tools=prelaunch-radar/new-shopify-stores-pre-launch-radar`) and
  call it from Claude, ChatGPT, Cursor, CrewAI, LangChain or any MCP client.
- **API**: `POST https://api.apify.com/v2/acts/prelaunch-radar~new-shopify-stores-pre-launch-radar/run-sync-get-dataset-items`
  returns the JSON array directly.
- **x402**: agents can pay per call without an Apify account.
- Minimal inputs:
  - `{"mode": "feed", "sinceDays": 1}` — today's new stores
  - `{"mode": "feed", "status": "pre-launch", "countries": ["US"], "maxItems": 50}`
  - `{"mode": "enrich", "domains": ["example.com"]}`
- `maxItems` is a hard cap on billed results, so an agent's spend is bounded before the run.

### Scheduling

Run the feed every day with `"sinceDays": 1` (Apify Schedules, n8n, Make, Zapier) to receive
the stores detected yesterday and today; deduplicate on `store_domain`.

### Pricing

Pay per result: you pay for each store delivered (feed) or each domain checked (enrich).
Stores filtered out are never billed. `Max results` caps your spend.

### How it's built

Public Certificate Transparency logs (RFC 6962), public DNS records pointing to Shopify,
the official RDAP registry, and each store's public `/meta.json` and `/products.json`.

### LEGAL DISCLAIMER

This dataset is provided for market research, trend analysis, and competitive intelligence
purposes only, on an "as-is" and "as-available" basis without warranties of any kind.
Records originate exclusively from publicly accessible sources (Certificate Transparency
logs, public DNS and RDAP registries, and stores' public storefront metadata); no personally
identifiable information (PII) is collected or sold.
Independently developed, not affiliated with, authorized, or endorsed by Shopify Inc. By
accessing this data, you agree that the provider shall not be liable for any direct or
indirect damages resulting from its use; in any event, liability is limited to the purchase
price.

# Actor input Schema

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

feed = list newly detected Shopify stores. enrich = check your own list of domains (fill 'domains').

## `sinceDays` (type: `integer`):

feed mode only. Return stores first detected in the last N days (1 = yesterday and today).

## `status` (type: `string`):

feed mode only. 'pre-launch' = store still behind its password page; 'live' = open storefront.

## `niches` (type: `array`):

feed mode only. Keep only these niches. Empty = all niches.

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

feed mode only. ISO 3166-1 alpha-2 codes of the store's country, e.g. US, GB, FR. Empty = all countries.

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

enrich mode only. Domains or URLs, one per item, e.g. example.com. Up to maxItems are checked.

## `maxItems` (type: `integer`):

Hard cap on the number of billed results (stores or domains) for this run.

## Actor input object example

```json
{
  "mode": "feed",
  "sinceDays": 7,
  "status": "any",
  "countries": [],
  "maxItems": 100
}
```

# Actor output Schema

## `results` (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 = {
    "countries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("prelaunch-radar/new-shopify-stores-pre-launch-radar").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 = { "countries": [] }

# Run the Actor and wait for it to finish
run = client.actor("prelaunch-radar/new-shopify-stores-pre-launch-radar").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 '{
  "countries": []
}' |
apify call prelaunch-radar/new-shopify-stores-pre-launch-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,prelaunch-radar/new-shopify-stores-pre-launch-radar"
        }
    }
}
```

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/4X45fJ07sfwNURl31/builds/cXhDGgPphsFE5v4t1/openapi.json