# Shopify Advertiser Leads Finder — $5/1K · Emails, Phones & Ads (`apivault_labs/shopify-advertiser-leads-finder`) Actor

Find Shopify stores running Facebook & Instagram ads. Verify live websites, export public business contacts and ad evidence. No login. Bulk CSV, JSON, Excel and API.

- **URL**: https://apify.com/apivault_labs/shopify-advertiser-leads-finder.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 verified shopify advertiser leads

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Advertiser Leads Finder

![Shopify Advertiser Leads Finder — active ads, verified stores and public contacts](https://api.apify.com/v2/key-value-stores/Iu1s2xj56xwxQlHSW/records/shopify-advertiser-readme-cover-v1.png?signature=1lf8sNui87zq9aE6vB79D)

Turn active Facebook and Instagram ads into a prospect list of verified Shopify stores. Get public business contacts, ad evidence and detected apps in one export.

- **Search by niche or Facebook Page ID.** Merge duplicate ads into one row per verified store.
- **Find contacts with sources.** Prefer store-domain emails and inspect the page and extraction method behind each contact.
- **Qualify prospects.** Filter by video ads, ad start dates, detected apps and supported agency service needs.
- **Export CSV, JSON or Excel.** Run in bulk through the API and connect n8n, Make or webhooks.

No Facebook login or external API key is required. An Apify account is needed to run the Actor; result and platform/proxy charges apply as described below.

Use it to prospect for Shopify development, email marketing, paid media and creative services. An active ad is evidence of advertising activity; it does not establish revenue, ad spend, profitability or a willingness to buy your service.

### Agency prospect research with reviewable advertising evidence

Use Shopify Advertiser Leads Finder to build a small list of stores for your own manual qualification. It connects observed active Meta ads with a checked Shopify website and whatever public business contacts the checked pages expose. Advertising activity, contact presence and detected apps are separate observations; none certifies a prospect's budget, consent or willingness to buy.

| Start with a question | Read these fields | Avoid this inference |
|---|---|---|
| Is this a checked Shopify site? | shopifyEvidence, technologies, checkedAt | A complete installed-app inventory |
| What advertising was observed? | adEvidence, activeAdsObserved, queriesMatched | Total ad spend, revenue or complete ad-library coverage |
| Where did a contact come from? | primaryEmailSource/Method/Relation | Verified mailbox delivery or marketing consent |
| Is the evidence complete enough to review? | pagesChecked, coverageWarnings, SUMMARY | A high score as a predicted conversion |

Start with explicit scan, website and result limits. Large defaults are useful for planned bulk work; a small first request is easier to inspect and budget.

### Quick start

```json
{
  "searchQueries": ["skincare"],
  "country": "US",
  "maxAds": 10000,
  "maxStoresToCheck": 1000,
  "maxResults": 1000,
  "requireEmail": false
}
```

The default result limit is **1,000 distinct store rows**, with a shared scan budget of 10,000 ads and up to 1,000 candidate websites checked. These defaults also apply when the API input omits the three limit fields. Existing Tasks and saved inputs retain their explicitly saved limits.

The Actor searches active Meta ads, checks matching landing websites for multiple Shopify signals, visits up to four pages per website for public contacts, and merges duplicate ads into a single store row. Requested result counts are ceilings, not guaranteed quantities. A store with many ads still produces one row. Source coverage, rejected websites, filters, spending limits and runtime can reduce delivery. A single keyword may not supply 1,000 verified Shopify stores; combine relevant keywords or Page IDs within the shared limits.

For a smaller first test, set `maxResults: 10`, `maxAds: 150` and `maxStoresToCheck: 40`. At the current rate, 1,000 delivered rows cost $5 in result fees **plus** platform/proxy usage; set a spending cap with resource headroom before a bulk run.

The country selects the **advertising market**, not the company's headquarters. Keywords must occur in an advertiser name or ad text. They do not guarantee that the company's main business belongs to that category.

### Preview before your first run

These five real stores were observed in a five-query US advertising-market QA scan on 16 October 2026 (Minsk). Email values are redacted in the downloadable preview; source URLs and ad links are retained. These examples illustrate fields and do not guarantee the same stores, contacts or result counts in your next run.

| Search | Store | Ads observed | Video ads | Email | Apps observed |
|---|---|---:|---:|---|---|
| skincare | froyaorganics.com | 23 | 9 | Store-domain email | Google Tag Manager, Klaviyo, Loox, Shopify |
| coffee | theloadedteashop.com | 3 | 3 | Store-domain email | Google Tag Manager, Judge.me, Recharge, Shopify |
| jewelry | enroutejewelry.com | 12 | 7 | Store-domain email | Google Tag Manager, Klaviyo, Shopify, TikTok Pixel |
| pet | uprootclean.com | 7 | 5 | Store-domain email | Google Tag Manager, Judge.me, Klaviyo, Okendo |
| fitness | gmwdfitness.com | 10 | 8 | Store-domain email | Google Tag Manager, Judge.me, Shopify |

[Download the CSV preview](https://api.apify.com/v2/key-value-stores/VWyigD1wfsCJPteuh/records/leads-preview.csv?signature=ySSKjGeO2eQgg7552Oy2) or [inspect the JSON preview](https://api.apify.com/v2/key-value-stores/VWyigD1wfsCJPteuh/records/leads-preview.json?signature=g33HAbThIl5ifypZJODK). Each real result pairs its public contact with a source URL, extraction method, Shopify evidence and active-ad observations. Email presence is not a deliverability test.

### Result fields

| Field | Meaning |
|---|---|
| `domain`, `website`, `storeName` | Verified website and its published title |
| `primaryEmail`, `primaryPhone` | Preferred public email and first phone; empty when unavailable |
| `primaryEmailRelation`, `primaryEmailSource`, `primaryEmailMethod` | Store-domain/provider/external-domain classification, source URL and extraction method. Store-domain contacts are preferred. |
| `emails`, `phones`, `socialProfiles` | Contacts paired with their source page URLs |
| `activeAdsObserved`, `videoAdsObserved` | Unique active ads found in this bounded scan, grouped by destination domain |
| `adEvidence`, `sampleAdUrl` | Up to ten ad examples with IDs, advertiser Page IDs, dates and landing URLs |
| `shopifyEvidence`, `technologies` | Website markers and the exact page checked |
| `pagesChecked`, `contactStatus`, `checkedAt` | Contact coverage and verification time |
| `queriesMatched`, `adSearchCountry` | Search context, not headquarters location |
| `historyStatus`, `firstDeliveredAt` | Optional delivery history: NEW or RETURNING, relative to your history key |
| `newestAdStart`, `oldestAdStart`, `adsStartedLast30DaysObserved` | Source-published start dates for the ads in your scan; not our discovery dates |
| `evidenceScore`, `scoreBreakdown`, `whyThisLead` | Transparent evidence-completeness score and readable observations; not a conversion or revenue prediction |
| `serviceFocus`, `serviceToolsChecked`, `serviceReviewNote` | Optional supported-tool screening for agency prospecting, with explicit review limitations |
| `homepageTruncated`, `coverageWarnings` | Pages above the 2 MiB HTML limit and contact-page failures are marked as partial coverage |

Use the Leads, Contacts, Agency or Evidence output views. Export CSV, JSON or Excel using Apify's dataset export, or integrate the Actor API with n8n, Make and webhooks. The primary email's source and extraction method are flat CSV fields, so you do not need to unpack the contact arrays.

### Filters and practical recipes

- **Contactable store leads:** set `requireEmail: true`. Emails are extracted from published pages; mailbox deliverability is not verified.
- **Video creative prospects:** set `minVideoAds: 1` and optionally `requireEmail: true`. Counts refer to ads observed in your scan, not the advertiser's full inventory.
- **Shopify app audiences:** set `includeTechnologies: ["Klaviyo"]`. All included technologies must be detected.
- **Exclude detected apps:** set `excludeTechnologies: ["Gorgias"]`. This means no matching marker was found on the checked homepage; an app may still be used elsewhere.
- **Specific advertisers:** set `facebookPageIds` to numeric Meta Page IDs, and use an empty `searchQueries` array. Ads must still lead to a live Shopify website.
- **Skip your customers:** use `excludeDomains`. Subdomains of excluded domains are skipped too.

Supported technology filters: Shopify, Klaviyo, Gorgias, Yotpo, Judge.me, Loox, Recharge, Attentive, Omnisend, Stamped.io, Okendo, Junip, Reviews.io, Privy, Mailchimp, Postscript, Tidio, Intercom, Zendesk, Re:amaze, Meta Pixel, TikTok Pixel, Google Tag Manager. These are observed HTML fingerprints, not an exhaustive app inventory. Tracking-pixel detection alone does not prove active advertising; every delivered row also needs a source ad explicitly marked active.

### Five ready-to-run prospecting recipes

**1. Public emails on the store's own domain**

```json
{"searchQueries":["skincare"],"country":"US","maxAds":90,"maxStoresToCheck":25,"maxResults":5,"requireStoreDomainEmail":true}
```

The primary email prefers the store's registrable domain, then public-mail providers, then external domains. Within those groups, explicit public sales/contact/support inboxes and mailto links get priority. Visible obfuscated and Cloudflare-protected public emails are decoded. This is an extraction preference, not proof of mailbox delivery, ownership or consent to receive messages.

**2. Video advertisers with ads started in the last 30 days**

```json
{"searchQueries":["skincare"],"country":"US","maxAds":90,"maxStoresToCheck":25,"maxResults":5,"minVideoAds":1,"adsStartedWithinDays":30,"requireEmail":true}
```

The window filters individual ads, so every ad count in this run refers to matching active ads, not all active ads ever observed for that store. Unknown and implausibly future start dates do not satisfy an enabled window. A recent ad does not establish a new advertiser or increasing ad spend.

**3. Klaviyo users with live advertising**

```json
{"searchQueries":["skincare"],"country":"US","maxAds":90,"maxStoresToCheck":25,"maxResults":5,"includeTechnologies":["Klaviyo"],"requireEmail":true}
```

**4. Customer-support tools not detected**

```json
{"searchQueries":["skincare"],"country":"US","maxAds":90,"maxStoresToCheck":25,"maxResults":5,"serviceFocus":"customer-support","requireEmail":true}
```

`serviceFocus` can be `general`, `email-marketing`, `reviews`, `subscriptions` or `customer-support`. Non-general modes skip stores where a supported target tool is detected and skip truncated homepages. The checked tools are returned in `serviceToolsChecked`. Email/SMS checks Klaviyo, Omnisend, Attentive, Privy, Mailchimp and Postscript; reviews checks Yotpo, Judge.me, Loox, Stamped.io, Okendo, Junip and Reviews.io; subscriptions checks Recharge; support checks Gorgias, Tidio, Intercom, Zendesk and Re:amaze. Unlisted tools and hidden integrations may still be used. Review the evidence before pitching a service.

**5. Only advertisers new to your delivered list**

```json
{"searchQueries":["skincare"],"country":"US","maxAds":90,"maxStoresToCheck":25,"maxResults":5,"historyMode":"ONLY_NEW","historyKey":"my-weekly-shopify-prospects","requireEmail":true}
```

The Actor's public Examples tab may have fewer presets while Apify's account-level published-Task quota is being reviewed. These inputs work directly in the Actor, API or your own Task.

### Evidence score

`evidenceScore` describes the completeness of observed evidence. The published formula is: verified Shopify +20; observed active ads +2 each, capped at 20; public email +30 for a store-domain email, +20 for a public-mail provider or +10 for an external-domain email; public phone +10; video-ad evidence +10; at least one observed ad started in the last 30 days +10; truncated homepage −10. The total is capped to 0–100. `scoreBreakdown` shows the actual points. It is not calibrated against customer purchases, conversions, brand revenue or advertising budgets. Results are delivered in bounded verification batches, not globally sorted by this score; sort your exported dataset if needed.

### Recurring runs and new stores only

```json
{
  "searchQueries": ["skincare"],
  "country": "US",
  "maxAds": 150,
  "maxResults": 5,
  "historyMode": "ONLY_NEW",
  "historyKey": "my-skincare-prospecting-list"
}
```

`TRACK` labels delivered stores NEW or RETURNING. `ONLY_NEW` excludes previously delivered domains. History is disabled by default. Supply a stable `historyKey` to enable it. The Actor creates a private named key-value store in the account running it; SUMMARY contains its ID. History keys are isolated by account and Actor. Only delivered results are remembered. The history holds up to 50,000 domains; use a new history key to begin a new list. Named history storage is retained until you delete it and can incur storage usage.

Run one job at a time for each history key. Overlapping jobs using the same key are not supported and can overwrite history. NEW means new to your delivered list, not a newly opened business or a newly launched advertising account. Starting another history key resets that comparison.

### Limits and source failures

`maxAds` bounds the scanned ads across all searches (maximum 10,000). Multiple searches share this budget. `maxStoresToCheck` bounds verified candidate websites (maximum 1,000). `maxResults` bounds delivered rows (maximum 1,000). The run's SUMMARY record shows scan, website, result and spending limits, skipped rows and incomplete searches. Its `searches` array reports each query/Page ID, allocated budget, returned ad count and whether collection ended, hit that budget or had a source error. `searchesSkippedByBudget` reports targets the shared cap prevented from being attempted. Page-ID searches reject ads belonging to another Page, and pagination retains one search session across pages.

New runs default to 512 MiB and a one-hour platform timeout. Large scans first collect ads, then verify candidate websites; progress counts appear in the run log. Once ad collection completes, the Actor saves a compressed candidate snapshot in the run's private default key-value store and saves website progress after each completed batch. A migration or reboot during website verification reuses that snapshot and completed checks. Delivered rows are reconciled with the dataset to prevent duplicate result charges. An unfinished batch may be retried; a migration during the initial ad collection can still repeat that unfinished scan. The checkpoint adds storage/API usage and follows the run store's retention settings.

The Actor stops admitting new website batches near its original run deadline and reports `runtimeLimited` in SUMMARY when time reduces coverage. This deadline does not reset after a migration. Explicit spending and result limits still apply.

Public Meta requests use Apify residential proxy. Residential proxy access is required for hosted collection; usage is billed separately. No cookies or credentials need to be entered in the input. Websites use direct HTTP first, with a residential proxy retry for failed requests. JavaScript, blocking or login can still prevent collection. Websites are omitted when Shopify cannot be verified. Missing contacts stay empty. Source failures are reported; a failure of every advertising search fails the run instead of producing a misleading successful empty result. Partial source results can still be delivered with an incomplete-search warning in SUMMARY.

Counts are bounded observations. Multiple advertisers may link to one store; those ads are combined, and Page IDs are preserved. Cross-domain website redirects are skipped to avoid assigning contacts to the wrong store. Marketplace destinations and unsupported link shorteners are skipped. Ad evidence links may later expire or show an inactive ad.

### Pricing

**$5 per 1,000 delivered store rows** on every Apify plan, plus platform and proxy usage. There is no separate Actor start fee. Check the Store Pricing tab for the effective rate. Only delivered store rows incur result charges; rejected websites, duplicate ads, empty results and errors do not incur result charges. Platform compute, storage, network and residential proxy usage are separate and can apply even when no store qualifies. Set both scan limits and a run spending limit before large runs; the platform run cap (`maxTotalChargeUsd`) includes result events and caller-paid platform/proxy usage. Leave room for resources instead of setting it to the exact nominal row price. The Actor subtracts reported resource usage before admitting more result rows, but billing totals may lag and Apify can still stop a run at its cap.

### Weekly new leads to Google Sheets with n8n

[Download the n8n workflow](https://api.apify.com/v2/key-value-stores/VWyigD1wfsCJPteuh/records/shopify-advertisers-weekly-to-sheets.json?signature=1kF72AiP0uIDZ726yxmpE) and [setup instructions](https://api.apify.com/v2/key-value-stores/VWyigD1wfsCJPteuh/records/n8n-setup.md?signature=1Rkz6617vLJxuKPB8GbAx); [sheet header row](https://api.apify.com/v2/key-value-stores/VWyigD1wfsCJPteuh/records/sheet-headers.csv?signature=GsditoFyoes4f8hxoNeO). Import it, select your own Apify header-auth and Google Sheets credentials, and set your spreadsheet ID. It starts inactive. Default: Monday09:00 Europe/Minsk, up to25 contactable stores, `ONLY_NEW`, one execution per history key at a time.

The flow starts one Actor job, waits for success, reads its dataset and updates/appends rows by domain using RAW cell values. If the Sheet write fails, replay the same run dataset: `ONLY_NEW` remembers delivery to Apify before Sheets succeeds. Do not create a new Actor job to recover that delivery. Template structure and transformations are checked; a real Google Sheets execution requires your connected credentials and destination.

### API

Run `apivault_labs/shopify-advertiser-leads-finder` through the Apify API, then read its default dataset. Use your Apify token in an Authorization header. The same input works from the Console, API and scheduled Tasks. Connect a run-success webhook to your own workflow to process the dataset after completion.

### Small Shopify advertiser API samples

Begin with one delivered store, a bounded ad scan and a few checked candidates. Source conditions can yield fewer than the ceiling. Keep history off while learning the output shape so a test does not update your recurring delivered-list campaign.

```json
{
  "searchQueries": [
    "skincare"
  ],
  "country": "US",
  "maxAds": 30,
  "maxStoresToCheck": 10,
  "maxResults": 1,
  "maxConcurrency": 2,
  "requireEmail": false,
  "historyMode": "OFF"
}
```

For a public business-contact sample, enable requireEmail and keep the same bounded scan. A stricter filter can reduce the output to zero; it does not expand the scan budget automatically.

```json
{
  "searchQueries": [
    "coffee"
  ],
  "country": "US",
  "maxAds": 50,
  "maxStoresToCheck": 15,
  "maxResults": 3,
  "requireEmail": true,
  "historyMode": "OFF"
}
```

#### Keep scan coverage separate from lead quality

maxAds, maxStoresToCheck and maxResults constrain different stages. A small ad sample can repeatedly point at the same domain; one verified store remains one delivered row. Review per-search counters and skipped targets before comparing niches. Country is the ad market, not a verified company address. Unknown ad start dates do not satisfy an enabled recency filter.

App absence means no supported marker was detected in the checked content. Truncated pages and hidden or unrecognized integrations limit that inference. serviceFocus is a bounded tool-screening aid for your own review, not proof that a store lacks a service or needs an agency. The evidence score measures available evidence, not commercial attractiveness.

#### Recover a downstream export without recollecting

Retain the original run ID and dataset ID when handing leads to a Sheet or CRM. If a destination write fails, replay that existing Dataset instead of starting another ONLY_NEW run: delivery history is updated at the Actor side, before your downstream destination succeeds. Keep one execution per historyKey; this is not an atomic multi-writer campaign store.

### Shopify advertiser API questions

**What is the paid result?** One verified, delivered Shopify store costs $0.005 in result events. There is no start fee. Residential proxy, compute, storage and other platform usage are extra and can apply even when no store qualifies. Leave resource headroom in the platform run cap.

**Can I get verified email deliverability?** No. The Actor extracts published contacts and records their source and method. Prefer original page evidence and your own review; no mailbox-validation or outreach action is performed.

**Is there a dedicated npm package?** A dedicated public npm package/client repository was not verified in this documentation pass. Use the existing downloadable n8n workflow and setup files below, generic Apify/HTTP nodes or standard API clients. The workflow template does not establish a completed Google Sheets execution with your credentials.

**Will five saved recipes appear as public Tasks?** Existing Tasks can remain private under account publication limits. These JSON recipes are usable directly; this README update preserves all existing Tasks and does not recheck or change that quota.

# Actor input Schema

## `searchQueries` (type: `array`):

Match keywords in ad text or advertiser names. These are not guaranteed company industry labels. Use keywords, numeric Page IDs, or both.

## `facebookPageIds` (type: `array`):

Optional numeric advertiser Page IDs. Set searchQueries to \[] to search only these advertisers.

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

Two-letter country code or ALL. Selects ad delivery/search market, not headquarters.

## `maxResults` (type: `integer`):

Maximum distinct qualified Shopify domains delivered. Defaults to 1,000, not a guaranteed quantity. Source coverage, filters, spending and runtime limits can reduce delivery.

## `requireEmail` (type: `boolean`):

Deliver only stores with an email published on checked pages. Does not verify mailbox deliverability.

## `requireStoreDomainEmail` (type: `boolean`):

Require at least one published email sharing the store’s registrable domain. Excludes provider and external domains; does not verify the mailbox.

## `serviceFocus` (type: `string`):

For a non-general focus, skip stores where supported target tools are detected. Incomplete homepages are skipped. Undetected is not proof the service is missing; review serviceToolsChecked and serviceReviewNote.

## `adsStartedWithinDays` (type: `integer`):

Keep only active ads whose source start date falls within this many days. 0 disables. Unknown/future dates do not match an enabled window; counts then cover only matching ads.

## `minActiveAds` (type: `integer`):

Unique active ads found for this domain within the bounded scan. Not the advertiser total.

## `minVideoAds` (type: `integer`):

Require video ads observed in the current scan; use 1 for video creative prospects.

## `includeTechnologies` (type: `array`):

Every selected technology must be detected on the live homepage. Supported: Shopify, Klaviyo, Gorgias, Yotpo, Judge.me, Loox, Recharge, Attentive, Omnisend, Stamped.io, Okendo, Junip, Reviews.io, Privy, Mailchimp, Postscript, Tidio, Intercom, Zendesk, Re:amaze, Meta Pixel, TikTok Pixel, Google Tag Manager.

## `excludeTechnologies` (type: `array`):

Skip a store when any listed technology is detected. Undetected does not prove an app is absent.

## `excludeDomains` (type: `array`):

Skip existing customers and their subdomains. Use bare public domains.

## `maxAds` (type: `integer`):

Shared scan budget across all queries and Page IDs. More scanned ads can mean more proxy usage even if no store qualifies.

## `maxStoresToCheck` (type: `integer`):

Candidates ranked by observed active-ad count. Each checked website uses at most four pages.

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

Parallel website checks; advertising searches are sequential.

## `historyMode` (type: `string`):

OFF disables history; TRACK labels new/returning; ONLY_NEW skips previously delivered stores. One job at a time per key.

## `historyKey` (type: `string`):

Required with TRACK/ONLY_NEW. Stable private list name; history is scoped to the calling account. Not a newly opened business detector.

## Actor input object example

```json
{
  "searchQueries": [
    "skincare"
  ],
  "country": "US",
  "maxResults": 1000,
  "requireEmail": false,
  "requireStoreDomainEmail": false,
  "serviceFocus": "general",
  "adsStartedWithinDays": 0,
  "minActiveAds": 1,
  "minVideoAds": 0,
  "maxAds": 10000,
  "maxStoresToCheck": 1000,
  "maxConcurrency": 4,
  "historyMode": "OFF"
}
```

# Actor output Schema

## `leads` (type: `string`):

No description

## `summary` (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 = {
    "searchQueries": [
        "skincare"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/shopify-advertiser-leads-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 = { "searchQueries": ["skincare"] }

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/shopify-advertiser-leads-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 '{
  "searchQueries": [
    "skincare"
  ]
}' |
apify call apivault_labs/shopify-advertiser-leads-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/shopify-advertiser-leads-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/AHISI8K2bIB59TCPh/builds/37pfvQLVusk5XGA1g/openapi.json