# Shopify Subscription Leads Scraper (`automation-lab/shopify-subscription-leads-scraper`) Actor

Qualify Shopify storefronts for DTC outreach with public subscription-provider, contact, social, and confidence signals.

- **URL**: https://apify.com/automation-lab/shopify-subscription-leads-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Shopify Subscription Leads Scraper

Qualify a list of public DTC storefronts for Shopify and subscription signals.

Bring your own domains or homepage URLs. The actor fetches each public homepage,
then returns evidence that helps an agency decide which brands merit outreach.

### What does it do?

It detects publicly visible Shopify markers and recurring-subscription clues.

It also classifies recognizable subscription providers such as Recharge, Skio,
Loop, Appstle, Bold, Seal, and Yotpo when their public HTML markers are present.

### Who is it for?

- 🔎 DTC subscription agencies building a qualified outreach list.
- 🤝 Shopify-app partners looking for publicly observable fit signals.
- 📊 RevOps teams enriching a known account list before sequencing.
- 🛍️ Market researchers comparing storefront technology signals.

### Why use it?

Generic ecommerce leads are noisy. A public subscription signal can help prioritize
stores that may have recurring-revenue operations, retention workflows, or relevant
Shopify-app needs.

The actor records evidence instead of making hidden assumptions.

### Important scope

This is a **lead qualification** scraper, not a store-discovery directory.

You supply `startUrls`. It does not search Google, enumerate Shopify shops, access
the Shopify Admin API, log into a storefront, or bypass a private area.

### What counts as evidence?

Shopify evidence includes public CDN, theme-data, asset-path, and generator markers.

Subscription evidence includes public subscription, subscribe-and-save, recurring
delivery, and autoship wording plus provider-specific public script/content markers.

### Confidence levels

| Confidence | Meaning |
| --- | --- |
| `high` | Multiple Shopify markers plus a provider or multiple subscription signals |
| `medium` | Shopify plus a subscription or provider signal |
| `low` | One partial Shopify, provider, or subscription indicator |
| `none` | No supported signal was found in the fetched public HTML |

Signals are useful qualification evidence, not proof that a merchant currently sells
subscriptions or uses a paid provider plan.

### Input

| Field | Description |
| --- | --- |
| `startUrls` | Required storefront URLs or bare domains you provide |
| `maxItems` | Maximum storefronts to process, default 10 |
| `requestTimeoutSecs` | Bounded per-store timeout, default 30 seconds |

Start with a small list to validate your workflow.

### Quick start

1. Add storefront URLs in **Storefront URLs or domains**.
2. Set a low `maxItems` value for your first run.
3. Run the actor.
4. Filter output by `confidence`, `isShopify`, or `subscriptionProviders`.
5. Review `shopifySignals` and `subscriptionSignals` before outreach.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.allbirds.com" },
    { "url": "https://your-known-store.example" }
  ],
  "maxItems": 2,
  "requestTimeoutSecs": 30
}
````

### Output

Each attempted storefront produces one row, including failures.

| Field | Description |
| --- | --- |
| `inputUrl` / `finalUrl` | Submitted URL and final redirected URL |
| `domain`, `title`, `statusCode` | Public storefront metadata |
| `isShopify`, `shopifySignals` | Shopify detection and matched evidence |
| `subscriptionSignals` | Matched generic recurring-commerce evidence |
| `subscriptionProviders` | Deterministically matched provider names |
| `confidence` | Evidence-based qualification level |
| `publicEmail`, `publicPhone` | Publicly visible homepage contact data when available |
| `socialLinks` | Public social profile links found on the page |
| `error` | Per-store fetch/parse diagnostic, if any |

### Example output

```json
{
  "domain": "example-store.com",
  "isShopify": true,
  "shopifySignals": ["Shopify CDN", "Shopify theme data"],
  "subscriptionSignals": ["Subscription keyword"],
  "subscriptionProviders": ["Recharge"],
  "confidence": "high",
  "socialLinks": { "instagram": "https://instagram.com/example" }
}
```

### How much does it cost to qualify Shopify subscription leads?

The actor uses pay-per-event pricing: a small start event and one result event for
each successfully qualified storefront record. Apify account tiers receive automatic
per-result discounts. The exact current price is shown on the actor’s Apify page
before you run it.

### Data quality tips

- ✅ Use canonical storefront homepages rather than product URLs.
- ✅ Keep your supplied list current and deduplicated.
- ✅ Treat provider names as matched public evidence, not vendor-confirmed data.
- ✅ Review the raw signal arrays for high-value accounts.
- ⚠️ Some client-rendered sites may expose fewer signals in homepage HTML.

### Error diagnostics

A failure for one domain does not stop the list.

The row’s `error` field records malformed URLs, DNS failures, timeouts, and similar
per-store problems so you can retry only the affected accounts later.

### Integrations

Export the dataset to a CRM enrichment queue, Google Sheets, a data warehouse, or
a Zapier/Make workflow.

A common agency workflow is: upload a prospect domain list → qualify subscription
signals → route `high` and `medium` confidence stores to a researcher → personalize
outreach from the evidence fields.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/shopify-subscription-leads-scraper').call({
  startUrls: [{ url: 'https://www.allbirds.com' }], maxItems: 1,
});
const items = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.items);
```

### Python API

```python
from apify_client import ApifyClient
client = ApifyClient("APIFY_TOKEN")
run = client.actor("automation-lab/shopify-subscription-leads-scraper").call(
    run_input={"startUrls": [{"url": "https://www.allbirds.com"}], "maxItems": 1}
)
print(client.dataset(run["defaultDatasetId"]).list_items().items)
```

### cURL API

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~shopify-subscription-leads-scraper/runs?token=$APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"startUrls":[{"url":"https://www.allbirds.com"}],"maxItems":1}'
```

### MCP integration for Claude Code and Claude Desktop

Use this actor through Apify MCP in Claude Desktop or Claude Code. Add it from the
Claude Code CLI:

```bash
claude mcp add apify-shopify-leads --transport http \
  "https://mcp.apify.com?tools=automation-lab/shopify-subscription-leads-scraper"
```

For Claude Desktop, add this server to the `mcpServers` object in your configuration:

```json
{
  "mcpServers": {
    "apify-shopify-leads": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/shopify-subscription-leads-scraper"
    }
  }
}
```

Example prompts:

- “Qualify these storefront domains for public Shopify and subscription-provider signals and show the evidence.”
- “Check this DTC prospect list, then return only Shopify stores with Recharge, Skio, or Loop markers.”
- “Find public contact and social links for these storefronts and explain each confidence score.”

### Privacy and legality

Only submit storefronts you are entitled to analyze. Respect site terms, applicable
privacy laws, and outreach rules. The actor reads public homepage HTML only; do not
use output to infer sensitive information about people.

### Limitations

Provider detection is marker-based and intentionally conservative. A merchant may
use a provider whose assets are absent from the homepage, and a keyword match may be
marketing copy rather than an active subscription offer.

### Troubleshooting

#### Why is confidence `none` for a store I know uses Shopify?

The homepage may be client-rendered, proxied, customized, or missing the public
markers used by this HTTP-first actor. Inspect the evidence fields and retry a
canonical homepage URL.

#### Why is there an error row instead of no row?

The actor always emits a diagnostic row for an attempted storefront. Filter `error`
for retry lists without losing visibility into failed inputs.

### FAQ

#### Does it find Shopify stores for me?

No. Supply your own domains. This focused design avoids building a generic directory.

#### Does it require Shopify Admin credentials?

No. It never calls private Shopify or provider APIs.

#### Can I use bare domains?

Yes. The actor normalizes a supplied domain to HTTPS.

### Related scrapers

For broader public storefront qualification, pair this with
[Shopify Store Leads Scraper](https://apify.com/automation-lab/shopify-store-leads-scraper).

For Shopify marketing-stack qualification, see
[Shopify Klaviyo Gap Leads Scraper](https://apify.com/automation-lab/shopify-klaviyo-gap-leads-scraper).

### Support

Include the affected input URL and its diagnostic row when reporting a problem.

The evidence arrays make it possible to reproduce a classification without access to
your private CRM or outreach workflow.

# Actor input Schema

## `startUrls` (type: `array`):

Your supplied Shopify/DTC storefronts. Domains are accepted and normalized to HTTPS.

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

Safety limit for URLs processed from your list.

## `requestTimeoutSecs` (type: `integer`):

Record an error diagnostic and continue when a storefront does not respond in time.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.allbirds.com"
    }
  ],
  "maxItems": 3,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

## `storefronts` (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 = {
    "startUrls": [
        {
            "url": "https://www.allbirds.com"
        }
    ],
    "maxItems": 3,
    "requestTimeoutSecs": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/shopify-subscription-leads-scraper").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 = {
    "startUrls": [{ "url": "https://www.allbirds.com" }],
    "maxItems": 3,
    "requestTimeoutSecs": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/shopify-subscription-leads-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.allbirds.com"
    }
  ],
  "maxItems": 3,
  "requestTimeoutSecs": 30
}' |
apify call automation-lab/shopify-subscription-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/shopify-subscription-leads-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Subscription Leads Scraper",
        "description": "Qualify Shopify storefronts for DTC outreach with public subscription-provider, contact, social, and confidence signals.",
        "version": "0.1",
        "x-build-id": "pPgQwuNJ8v66uwZMw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~shopify-subscription-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-shopify-subscription-leads-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/automation-lab~shopify-subscription-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-shopify-subscription-leads-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/automation-lab~shopify-subscription-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-shopify-subscription-leads-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏪 Storefront URLs or domains",
                        "type": "array",
                        "description": "Your supplied Shopify/DTC storefronts. Domains are accepted and normalized to HTTPS.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum storefronts",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety limit for URLs processed from your list.",
                        "default": 10
                    },
                    "requestTimeoutSecs": {
                        "title": "Per-store timeout (seconds)",
                        "minimum": 5,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Record an error diagnostic and continue when a storefront does not respond in time.",
                        "default": 30
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```