# Shopify Store Scraper - Products, Variants, Prices & Leads (`scrapesage/shopify-store-scraper`) Actor

Scrape any Shopify store: products with variants, SKUs, prices, compare-at discounts, stock, images, options & tags, plus store intelligence and merchant leads (email, phone, socials). Modes for store, collection or product. Monitoring for new products & price drops. No login.

- **URL**: https://apify.com/scrapesage/shopify-store-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** E-commerce, Lead generation, Agents
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.10 / 1,000 result scrapeds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Store Scraper — Products, Variants, Prices, Inventory & Store Leads

> **Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Shopify Inc. or any of its subsidiaries. All trademarks mentioned are the property of their respective owners. "Shopify" is referenced only to describe the publicly available website this Actor collects data from.

Extract **complete product data from any [Shopify](https://www.shopify.com) store** — every product with all **variants, SKUs, barcodes, prices, compare-at discounts, inventory/stock, images, options and tags** — plus **store intelligence** (currency, country, payment methods, theme, product & collection counts) and the **merchant's contact lead** (email, phone, social profiles). Works on millions of Shopify stores. No login, no app, no API key.

Built for **dropshippers, product researchers, price-monitoring teams, and agencies/app-developers who sell to Shopify merchants**. Turn any store URL into a structured catalog — and turn the store owner into a ready B2B lead.

### Why this Shopify scraper?

Generic "paste-a-URL" crawlers grab a few visible fields and miss the data that actually matters. This actor reads Shopify's public product, collection and store endpoints directly and ships the **richest dataset in the category** — full variant arrays, computed price/discount/stock signals, store-level intelligence, and the merchant contact lead, in one clean table.

| Data | Generic crawlers | This actor |
|---|---|---|
| Product title, vendor, type, tags, description | partial | ✅ |
| **All variants** — SKU, barcode, price, compare-at, availability, weight, options | ❌ / partial | ✅ |
| Computed **price range, discount %, on-sale flag** | ❌ | ✅ |
| Computed **in-stock + in-stock variant count** | ❌ | ✅ |
| All product **images** (src, alt, position, dimensions) | partial | ✅ |
| **Store intelligence** — currency, country, payment cards, theme, product/collection counts | ❌ | ✅ |
| **Store-owner lead** — email, phone, Instagram/Facebook/TikTok/X/YouTube/Pinterest/LinkedIn | ❌ | ✅ |
| Scrape a whole store, a **collection**, or single **products** | partial | ✅ |
| **Monitoring mode** — only new products & price/stock changes | ❌ | ✅ |
| One clean dataset, no empty columns | ❌ | ✅ |

### Use cases

- **Product & niche research** — pull a competitor's full catalog with prices, variants and best-sellers signals to spot winning products and gaps.
- **Price & inventory monitoring** — track price drops, sell-outs and back-in-stock events across the stores you care about, on a schedule.
- **Dropshipping & sourcing** — export catalogs with SKUs, variants and images to seed your own store or supplier research.
- **Competitive intelligence** — compare assortment, pricing, discounts and payment options across an entire set of Shopify stores.
- **B2B lead generation** — use **Store leads** mode to prospect Shopify merchants: contact email, phone, socials and tech stack, ready for your CRM or outreach (perfect for agencies, app developers, 3PLs and B2B vendors who sell to Shopify brands).

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Shopify Store Scraper**, choose a **mode** (Products by default), and paste one or more store URLs (e.g. `https://www.allbirds.com` or just `rothys.com`).
3. Click **Start** and watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "products",
    "storeUrls": ["https://www.allbirds.com/", "rothys.com"],
    "maxProductsPerStore": 0,
    "enrichStoreLeads": true,
    "monitorMode": false
}
```

- **mode** *(default `products`)* — `products` (full catalog of each store in **storeUrls**), `collection` (products inside the **collectionUrls** you provide), `product` (single **productUrls**), or `store` (store intelligence + owner lead only, no products).
- **storeUrls** — one or more Shopify stores. Full URL, bare domain, or `*.myshopify.com` domain. Used by `products` and `store` modes.
- **collectionUrls** — full collection URLs (e.g. `…/collections/mens-shoes`) for `collection` mode.
- **productUrls** — full product URLs (e.g. `…/products/wool-runners`) for `product` mode.
- **maxProductsPerStore** *(default 0 = no limit)* — cap products per store for quick test runs.
- **onlyAvailable / minPrice / maxPrice** — filter to in-stock products and/or a price band (in the store's own currency).
- **includeVariants / includeImages** *(default true)* — include the full variant and image arrays.
- **includeStoreMeta** *(default true)* — attach store intelligence (from `meta.json`) to each product.
- **enrichStoreLeads** *(default true)* — read the storefront for the merchant's email, phone, socials and theme. Always on in `store` mode.
- **monitorMode** *(default false)* — emit only new/changed products (see below).
- **proxyConfiguration** — proxy settings (Apify Proxy by default; switch to Residential for the few large brands behind Cloudflare).

### Output

By default you get **one clean, dense table of products** — every column applies to every row. Use the **Products**, **Variants** and **Store leads** dataset views to switch the visible columns.

A product record (`mode: "products"`):

```json
{
    "mode": "products",
    "storeUrl": "https://www.allbirds.com/",
    "storeDomain": "www.allbirds.com",
    "store": {
        "name": "Allbirds",
        "myshopifyDomain": "weareallbirds.myshopify.com",
        "currency": "USD",
        "country": "US",
        "paymentCardBrands": ["visa", "master", "american_express"],
        "publishedProductsCount": 72,
        "publishedCollectionsCount": 1338,
        "email": "help@allbirds.com",
        "socials": { "instagram": "https://www.instagram.com/allbirds", "tiktok": "https://www.tiktok.com/@weareallbirds" },
        "theme": "Handover theme",
        "leadScore": 7
    },
    "id": 3687618936912,
    "title": "Trino® Tubers - Onyx",
    "handle": "trino-tubers-onyx",
    "url": "https://www.allbirds.com/products/trino-tubers-onyx",
    "vendor": "Allbirds",
    "productType": "Socks",
    "tags": ["unisex", "socks"],
    "description": "The Trino Tubers is a tube sock that hugs just below your calf…",
    "options": [{ "name": "Size", "position": 1, "values": ["S", "M", "L"] }],
    "featuredImage": "https://cdn.shopify.com/%E2%80%A6",
    "imageCount": 5,
    "price": 16,
    "priceMin": 16,
    "priceMax": 16,
    "compareAtPriceMax": null,
    "onSale": false,
    "discountPercent": 0,
    "currency": "USD",
    "variantCount": 4,
    "availableVariantCount": 2,
    "inStock": true,
    "variants": [
        { "id": 28848479666256, "title": "S (W5-7)", "sku": "ST1UONX101", "price": 16, "compareAtPrice": null, "available": false, "option1": "S (W5-7)", "grams": 99 }
    ],
    "images": [{ "src": "https://cdn.shopify.com/%E2%80%A6", "alt": "Trino Tubers Onyx", "position": 1 }],
    "scrapedAt": "2026-06-15T18:00:00.000Z"
}
```

A **store-lead** record (`mode: "store"`) is a flat row with `name`, `storeDomain`, `myshopifyDomain`, `currency`, `country`, `publishedProductsCount`, `paymentCardBrands`, `email`, `phone`, `instagram`/`facebook`/`tiktok`/`twitter`/`youtube`/`pinterest`/`linkedin`, `theme` and a `leadScore`.

#### What to expect (field coverage)

Shopify exposes products and store metadata publicly, so the catalog is highly complete. Some fields are merchant-entered and only present when the store filled them in:

| Field group | Coverage |
|---|---|
| Product core (title, handle, vendor, type, price, variants, images) | ✅ ~100% on stores that expose `products.json` |
| `barcode`, `inventoryQuantity`, `weight/weightUnit` | present when the store publishes them (varies by store) |
| Store intelligence (`meta.json`: currency, country, counts, payment cards) | ✅ when the store keeps `meta.json` public (most do) |
| Store lead `email` | ~50–70% (homepage/contact page) |
| Store lead `socials`, `theme` | ✅ usually present |

A blank field means the merchant didn't publish it — not that scraping failed. Nothing is dropped, so you always get the richest dataset available. A small number of large brands serve their storefront behind Cloudflare or use a headless (Hydrogen) front end without `products.json`; for those, switch to Residential proxy or expect them to be skipped with a clear log note.

### Monitoring mode — only new products & price drops

Turn on **monitorMode** to remember every product returned in previous runs and emit **only** products that are **new** or whose **price / discount / availability changed** since the last run. Each record is tagged `monitorStatus` (`new` or `changed`). It fingerprints on price and stock — not Shopify's volatile `updated_at` — so you get real signal, not noise.

Pair it with [Apify Schedules](https://docs.apify.com/platform/schedules): the schedule triggers the run on your cadence, and monitor mode remembers what it already returned across those runs (state is kept in a named key-value store, completely separate from the scheduler). New launches, price drops and back-in-stock events land straight in your dataset — perfect for a daily price-watch or a Slack/CRM alert.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly to track catalogs, prices and stock over time.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, restock email) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/shopify-store-scraper').call({
    mode: 'products',
    storeUrls: ['https://www.allbirds.com/'],
    monitorMode: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} products`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new products or price drops straight into your tools.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored store drops a price or adds a product.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "list every product and price from this Shopify store" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **e-commerce & marketplace intelligence stack**:

- **[Shopify App Store Scraper](https://apify.com/scrapesage/shopify-app-store-scraper)** — apps, pricing plans, ratings, reviews and developer leads from the Shopify App Store.
- **[Made-in-China Scraper](https://apify.com/scrapesage/made-in-china-scraper)** — B2B suppliers, products and company details for sourcing.
- **[Product Hunt Scraper](https://apify.com/scrapesage/product-hunt-scraper)** — launches, makers and maker leads.
- **[Google Play Scraper](https://apify.com/scrapesage/google-play-scraper)** — apps, reviews and developer leads.
- **[Apple App Store Scraper](https://apify.com/scrapesage/app-store-scraper)** — apps, reviews and charts.
- **[Chrome Web Store Scraper](https://apify.com/scrapesage/chrome-web-store-scraper)** — extensions, ratings, reviews and developer leads.
- **[Steam Scraper](https://apify.com/scrapesage/steam-scraper)** — games, prices, reviews and charts.
- **[Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)** — competitor ad intelligence on Meta & Instagram.

### Tips

- **Pick a single mode** for a clean, fully-populated table. Use `products` for whole-store catalogs, `collection` to target a specific collection, `product` for a handful of URLs, and `store` for pure lead lists.
- **Store leads**: keep `enrichStoreLeads` on to capture the merchant's email, phone, socials and theme — it's the difference between a product row and a contactable lead.
- **Big catalogs**: leave `maxProductsPerStore` at 0 to get everything; products stream in pages of up to 250 so rows appear within seconds.
- **Large brands behind Cloudflare**: a few big stores front their storefront with Cloudflare or run a headless (Hydrogen) front end — switch `proxyConfiguration` to Residential for those, or expect a clear skip note in the log.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to track price drops and new launches automatically.

### FAQ

**Which stores work?** Any store running Shopify that keeps its public product endpoints available — that's the large majority of the millions of Shopify stores. Paste the store's main domain or its `*.myshopify.com` domain.

**Does it need the Shopify Admin API or an access token?** No. This actor reads Shopify's public storefront endpoints (`products.json`, `collections/<handle>/products.json`, `products/<handle>.json`, `meta.json`) — no key, app install or login needed.

**Can I get inventory quantities?** You get per-variant **availability** (in stock / out of stock) and an in-stock variant count on every store. Exact on-hand quantities are only returned by stores that publish them — many don't expose that publicly.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I track price drops and new products?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules). Each run returns only products that are new or whose price/stock changed, tagged `monitorStatus`.

**A field is empty — why?** Some merchants don't publish barcodes, weights or a contact email, and some big brands hide `products.json`. Fields are blank only when the store didn't publish that data — never because the scraper skipped it.

**Is scraping Shopify stores legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA for personal data) and the stores' terms.

### Disclaimer

**This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Shopify Inc. or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.**

"Shopify" and any related marks are the property of their respective owners and are used here only in a descriptive, nominative sense - to identify the publicly accessible website from which this Actor collects data. This Actor is not an official Shopify product, is not authorised or certified by Shopify Inc., and does not distribute Shopify software. It collects only publicly available information; you are responsible for ensuring your use of that data complies with applicable laws, regulations and the terms of the source website.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

`Products` (default) pulls the full catalog of every store in **Store URLs**. `Collection` pulls only the products inside the collection URLs you provide. `Product` pulls single product pages from **Product URLs**. `Store leads` skips products and returns one rich store-intelligence + contact-lead record per store (cheap B2B prospecting of Shopify merchants).

## `storeUrls` (type: `array`):

One or more Shopify store URLs or domains (used by the **Products** and **Store leads** modes). Accepts the full URL, a bare domain, or the `*.myshopify.com` domain, e.g. `https://www.allbirds.com`, `rothys.com`, or `weareallbirds.myshopify.com`.

## `collectionUrls` (type: `array`):

Used by **Collection** mode. Full Shopify collection URLs, e.g. `https://www.allbirds.com/collections/mens-shoes`. The actor returns the products inside each collection.

## `productUrls` (type: `array`):

Used by **Product** mode. Full Shopify product URLs, e.g. `https://www.allbirds.com/products/mens-wool-runners`. The actor returns one full product record per URL.

## `maxProductsPerStore` (type: `integer`):

Cap the number of products scraped from each store (0 = no limit, get the whole catalog). Handy for quick test runs.

## `onlyAvailable` (type: `boolean`):

Skip products that have no purchasable (in-stock) variant.

## `minPrice` (type: `integer`):

Only keep products whose lowest variant price is at least this value (in the store's own currency). 0 = no minimum.

## `maxPrice` (type: `integer`):

Only keep products whose lowest variant price is at most this value (in the store's own currency). 0 = no maximum.

## `includeVariants` (type: `boolean`):

Include the full per-variant array (SKU, barcode, price, compare-at, availability, weight, options). Turn off for a lighter, product-level-only dataset.

## `includeImages` (type: `boolean`):

Include the full product image array (src, alt, position, dimensions).

## `includeStoreMeta` (type: `boolean`):

Attach store-level data (name, currency, country, payment methods, product/collection counts) to each product, read from the store's public `meta.json`.

## `enrichStoreLeads` (type: `boolean`):

Read each store's homepage (and contact page) to extract the merchant's contact email, phone, social profiles and Shopify theme — the B2B lead wedge. Adds one or two lightweight requests per store. Always on in **Store leads** mode.

## `monitorMode` (type: `boolean`):

Remember products returned in previous runs and emit ONLY products that are new or whose price / availability / update time changed since last run. Perfect for tracking new launches, price drops and back-in-stock events. Each record is tagged `monitorStatus` (new / changed). Pairs with Apify Schedules — schedule the run, this remembers what it already returned.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the per-product fingerprints used by monitoring mode. Use a different name per tracked set of stores to keep histories separate. Lowercase letters, digits and hyphens only.

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

Maximum number of stores / pages fetched in parallel.

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

Proxy settings. Shopify's public JSON endpoints are reachable from datacenter IPs on most stores (the default). A few large brands front their storefront with Cloudflare — switch to Apify Residential proxy to reach those.

## `urlsFromFile` (type: `string`):

Paste a list of URLs (one per line), OR one link to a .txt/.csv file, Google Sheet or Google Drive file containing them. Lets you import many Start URLs at once instead of typing each. Google Sheet/Drive share links are handled automatically.

## Actor input object example

```json
{
  "mode": "products",
  "storeUrls": [
    "https://www.allbirds.com/"
  ],
  "maxProductsPerStore": 0,
  "onlyAvailable": false,
  "minPrice": 0,
  "maxPrice": 0,
  "includeVariants": true,
  "includeImages": true,
  "includeStoreMeta": true,
  "enrichStoreLeads": true,
  "monitorMode": false,
  "monitorStoreName": "shopify-store-monitor",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset. Product rows (Products / Collection / Product modes) and store-lead rows (Store-leads mode) are each tagged with a `mode` field; use the Products / Variants / Store leads dataset views to filter the columns.

# 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 = {
    "storeUrls": [
        "https://www.allbirds.com/"
    ],
    "urlsFromFile": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/shopify-store-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 = {
    "storeUrls": ["https://www.allbirds.com/"],
    "urlsFromFile": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/shopify-store-scraper").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 '{
  "storeUrls": [
    "https://www.allbirds.com/"
  ],
  "urlsFromFile": ""
}' |
apify call scrapesage/shopify-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/esRzYuMw2k9blv0Lm/builds/HdbvuJbnshYkBX61E/openapi.json