# Shopify Script Tag Shutoff Scanner (March 2027) (`donrulezz/shopify-script-tag-scanner`) Actor

Shopify stops running script tags (ScriptTag API) on storefronts on 1 March 2027. Scan any Shopify stores: which apps still load via ScriptTags, which already have an app embed, the theme, legacy customer accounts and what to switch on. Public pages only.

- **URL**: https://apify.com/donrulezz/shopify-script-tag-scanner.md
- **Developed by:** [Ashish Agarwal](https://apify.com/donrulezz) (community)
- **Categories:** E-commerce, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 shopify store scanneds

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Shopify Script Tag Shutoff Scanner (March 2027)

**On 1 March 2027 Shopify stops injecting script tags into online store storefronts**, on every API version
([shopify.dev changelog, 24 Aug 2026](https://shopify.dev/changelog/online-store-script-tags-deprecation)). Apps that
still load that way (chat widgets, reviews, loyalty, subscriptions, pop-ups, fraud and ID checks...) will silently
disappear from the store unless the merchant switches on the app's **app embed** in the theme editor.

Merchants can't see their script tags in the admin, and an app can only list its own tags. This Actor reads the public
storefront of any Shopify store and tells you, per store:

- **Which apps still load through script tags** (each script URL, mapped to the app name),
- **Which of them already have an app embed switched on** (safe) and which don't (**will stop on 1 Mar 2027**),
- the **theme** (name, version, theme store id, vintage flag),
- whether the store still runs **legacy customer accounts** (deprecated by Shopify on 26 Feb 2026; the final sunset date
  is to be announced),
- a **risk level** and a plain to-do list for the merchant.

Built for Shopify agencies and freelancers (find and fix affected client stores), app vendors (see which merchants still
run your old script tag) and merchants (check your own store before the date).

### Input

```json
{ "storeUrls": ["https://www.brooklinen.com", "example.myshopify.com"] }
```

Or give `storeListUrl`: a CSV/TXT file or a published Google Sheets CSV link; any column holding a domain or
URL is used, one store per row.

Only the home page is read (script tags with an online-store scope load on every page; the customer-account check
uses the same page and asks `/account/login` only when the page doesn't say). Requests are paced (about one store per
second) because Shopify rate-limits bursts from one address; stores that keep refusing are reported as errors and are
not charged, so you can simply run them again later.

### Output

```json
{
  "url": "https://shop.example.com",
  "isShopify": true,
  "shopDomain": "example.myshopify.com",
  "risk": "high",
  "atRiskApps": ["Recharge", "Fomo"],
  "scriptTagCount": 3,
  "scriptTags": [
    {"url": "https://config.gorgias.chat/bundle-loader/...", "host": "config.gorgias.chat", "app": "Gorgias", "hasAppEmbed": true},
    {"url": "https://static.rechargecdn.com/assets/js/widget.min.js", "host": "static.rechargecdn.com", "app": "Recharge", "hasAppEmbed": false}
  ],
  "appEmbeds": ["gorgias-chat"],
  "theme": {"name": "Dawn", "schemaName": "Dawn", "schemaVersion": "15.2.0", "themeStoreId": 887, "vintage": false},
  "customerAccounts": "legacy",
  "action": "2 app(s) load only through script tags and stop on 1 Mar 2027: Recharge, Fomo. For each: update the app, then turn on its app embed in Online Store > Themes > Customize > App embeds..."
}
```

Risk: `high` = at least one app loads only through script tags; `low` = script-tag apps also have an app embed (only
the old copy goes away); `none` = no script tags; `not-shopify` = not a Shopify Liquid storefront (headless stores
don't use script tags). The key-value store `summary` lists the apps most often still on script tags across your scan.

### How it works

Shopify loads script tags through its `asyncLoad` storefront loader; app embeds load from
`cdn.shopify.com/extensions/...`. The Actor reads both from the public HTML, maps script hosts to 80+ known apps
(unknown ones are shown by domain) and checks whether the same app already ships an embed. No login, no admin access,
no personal data, no contact with the store.

### Pricing

Pay per Shopify store scanned. Non-Shopify sites and stores that can't be loaded are free, and the run stops at your
spending limit.

### Good to know

- Analytics/conversion scripts should move to web pixels, which need no merchant action; storefront features need the
  app embed switched on by the merchant.
- Shopify said it will reassess its merchant warning in January 2027; the 1 March 2027 date stands as published.
- App names come from a lookup table; an unknown script shows its domain so you can still identify it.

### FAQ

**Will my Shopify store break on March 1, 2027?**
Only the parts that come from apps still loading through script tags. Shopify stops injecting script tags into online
store storefronts on 1 March 2027 (all API versions). Run this Actor on your store: `risk: high` lists the apps that will
disappear; `low` or `none` means you are fine.

**What replaces Shopify script tags?**
App embed blocks (theme app extensions), which the merchant turns on in Online Store > Themes > Customize > App embeds,
and web pixels for analytics and conversion tracking. Many apps already ship an app embed: the scan shows which ones are
already on.

**Why can't I see script tags in my Shopify admin?**
Shopify doesn't list them for merchants, and an app's API access only shows its own tags. The storefront's public HTML
still shows every script-tag URL, which is what this Actor reads.

**Since when can apps no longer create script tags?**
Since 1 October 2026 the `scriptTagCreate` / `scriptTagUpdate` mutations and REST POST/PUT return errors; existing tags
keep running until 1 March 2027.

**Does this work for headless (Hydrogen) stores?**
Headless storefronts don't use script tags, so they are reported as `not-shopify` (nothing to fix there).

**Can agencies scan many stores?**
Yes: paste a list of store URLs (thousands per run). The `summary` record ranks the apps most often still on script tags.

### More tools from the same author

- [Shopify Image Size Checker](https://apify.com/donrulezz/shopify-image-size-checker): every product image under the 500x500 Merchant Center minimum (31 January 2027).
- [Google Merchant Center Q\&A Writer](https://apify.com/donrulezz/merchant-center-qa-writer): write the new question_and_answer attribute for every product, as a ready supplemental feed.
- [AI Visibility Monitor](https://apify.com/donrulezz/ai-answer-engine-monitor): does ChatGPT, Perplexity, Claude or Gemini recommend your brand.
- [PayPal Legacy Button Finder](https://apify.com/donrulezz/paypal-legacy-button-finder): every old PayPal Buy Now / Add to Cart button before PayPal retires them.
- [SSL Root Certificate Distrust Checker](https://apify.com/donrulezz/root-certificate-distrust-checker): which sites, APIs and mail servers break when Mozilla removes 19 roots on 15 April 2027.
- [Azure Classic CDN & Front Door Retirement Checker](https://apify.com/donrulezz/azure-classic-cdn-front-door-checker): hostnames and page assets still on Front Door (classic) or azureedge.net.
- [Drupal Version & End-of-Life Checker](https://apify.com/donrulezz/drupal-version-eol-checker): which sites run Drupal 10 (end of life 9 December 2026) or older.
- [Website 2027 Breakage Audit](https://apify.com/donrulezz/website-2027-breakage-audit): every 2026-2027 deadline (certificates, Shopify, PayPal, Azure, Drupal, PHP) in one report per site.

*Shopify is a trademark of Shopify Inc. App names are trademarks of their owners. This Actor is independent and not affiliated with or endorsed by Shopify.*

# Actor input Schema

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

Shopify storefronts, one per line: custom domains (shop.example.com) or example.myshopify.com. Only the home page is read.

## `storeListUrl` (type: `string`):

A CSV/TXT file or a published Google Sheets CSV link; any column holding a domain or URL is used (one store per row).

## `checkCustomerAccounts` (type: `boolean`):

One extra request per store to /account/login: legacy (deprecated by Shopify on 26 Feb 2026, sunset date to be announced), new, or disabled/unknown.

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

Requests are paced (about 1.4 stores per second) because Shopify rate-limits bursts.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.brooklinen.com",
    "https://www.deathwishcoffee.com"
  ],
  "checkCustomerAccounts": true,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

Risk, apps that stop, app embeds, theme, action per store.

## `summary` (type: `string`):

Stores at risk and the apps most often still on script tags.

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

Every script-tag URL with its app and app-embed status.

# 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.brooklinen.com",
        "https://www.deathwishcoffee.com",
        "https://www.thesill.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("donrulezz/shopify-script-tag-scanner").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.brooklinen.com",
        "https://www.deathwishcoffee.com",
        "https://www.thesill.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("donrulezz/shopify-script-tag-scanner").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.brooklinen.com",
    "https://www.deathwishcoffee.com",
    "https://www.thesill.com"
  ]
}' |
apify call donrulezz/shopify-script-tag-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,donrulezz/shopify-script-tag-scanner"
        }
    }
}
```

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/iRPt0eOBfSGKy4Php/builds/RPrFg5IvWMdqakwW4/openapi.json