Shopify App Script Checker
Paste a product or collection page URL. The checker fetches the HTML and sorts every script tag into theme, Shopify platform, app and third-party, with loading flags, byte sizes for up to 30 scripts, the five heaviest, and the legacy ScriptTag list.
Short answer
A Shopify product page loads JavaScript from four places: the theme, Shopify's platform code, installed apps, and third-party hosts. This checker reads one page's HTML, counts each group, flags async, defer and blocking scripts, and sizes up to 30 external files. It does not run JavaScript, so runtime-injected scripts go uncounted, except the legacy ScriptTag list Shopify prints.
Where Shopify storefront JavaScript comes from
Every script on a storefront page was put there by one of four parties, and the path it loads from gives the party away. That matters because each group has a different owner, and the owner decides whether you can remove it.
- The theme. Files under /cdn/shop/t/<id>/assets/ and inline blocks written in Liquid. Edited in the theme code editor. Includes any tag a developer pasted into theme.liquid, which is where old app code hides.
- Shopify itself. Checkout preloads, Shop Pay, the web pixels manager, analytics and the performance kit, served from /cdn/shopifycloud/ and /cdn/wpm/ and written by content_for_header. Present on every store.
- Theme app extensions. App blocks and app embed blocks, with assets hosted on Shopify's CDN under /extensions/. Shopify renders app embeds before the closing head and body tags and wraps each in a comment naming the app.
- The legacy ScriptTag API. Remote URLs an app registered, which Shopify injects on window load. Theme app extensions replaced it in 2021 and Shopify stops running storefront script tags on March 1, 2027.
Third-party hosts cut across all four. An app embed is usually a small loader that fetches the vendor's real bundle from its own CDN, and a tag manager fans out to a dozen more. The checker lists every third-party host in the HTML and, separately, the hosts inline code names but no tag loads.
What the scan cannot see
This is an HTML scan, not a rendered load. Nothing executes, so a script another script creates at runtime is not a tag and is not counted. The legacy ScriptTag list is visible only because Shopify prints the URLs into the page for its loader to read.
Why app scripts dominate Core Web Vitals on Shopify stores
Google's thresholds for a good Core Web Vitals result, measured at the 75th percentile of real visits, are an LCP of 2.5 seconds or less, an INP of 200 milliseconds or less, and a CLS of 0.1 or less. Shopify's own performance guidance names JavaScript as the primary cause of poor INP and delayed LCP.
Shopify's help centre lists the three biggest factors in store performance as the theme, the installed apps, and third-party code added by hand, such as tag managers. The hosting, the CDN and image compression are Shopify's problem and are already handled. The scripts are yours.
How a script hurts each metric
- LCP. A parser-blocking script in the head delays every element below it, including the product image. Shopify's first JavaScript recommendation is to remove render-blocking apps.
- INP. Every kilobyte that executes on the main thread competes with the tap on Add to cart. Five review, upsell and chat widgets each doing a little add up to a page that answers late.
- CLS. App-injected content that arrives after paint, such as a banner or a reviews strip, pushes the page down. Shopify names app-injected content as a common cause.
Google's guidance on third-party JavaScript is short: load it with async or defer, self-host it if the vendor is slow, and remove it if it does not add clear value. This inventory is what lets you apply the third rule. The Shopify speed optimization guide covers the rest of the page.
How to read the report
The report answers one question per block: how much, from whom, and loaded how. Start at the group table and work down. The table below is the order to cut in, with what each group is and how it comes out.
| Script group | Where it comes from | Can you remove it? | How |
|---|---|---|---|
| Third-party origins | Any host that is not the store, cdn.shopify.com or shop.app: vendor CDNs, tag managers, chat, reviews, analytics | Yes, and first | Find the owner. An app embed: switch it off. A manual tag: delete it from theme.liquid. A tag manager child: remove the tag in the container |
| App scripts | Theme app extension assets under /extensions/, app embed blocks Shopify wraps in BEGIN app block comments, app proxy paths | Yes | Online Store, Themes, Customize, App embeds: switch off unused embeds. Uninstall apps you no longer use rather than leaving them installed |
| Legacy ScriptTag API | URLs in the asyncLoad list content_for_header prints, injected on window load by apps using the deprecated API | Yes, and soon by force | Ask the vendor for the theme app extension version. Shopify stops injecting storefront script tags on March 1, 2027 |
| Theme assets | /cdn/shop/t/<id>/assets/ files and inline Liquid output, including tags pasted by a developer | Some | Keep the theme's own sections. Search the theme code for vendor hostnames that no installed app explains and remove the include |
| Shopify platform | /cdn/shopifycloud/, /cdn/wpm/, checkout preloads, Shop Pay, analytics, perf kit | No | Nothing to do. Every store loads these and no theme setting drops them |
Loading flags: async, defer and blocking
An external script with neither async nor defer is marked blocking: the browser stops building the page until that file has downloaded and run. Modules defer by default. Shopify's guidance is defer for anything non-critical and async only for independent third-party scripts where order does not matter.
The five heaviest table combines sized external files with the length of each inline block. A 50 KB inline block from an app embed costs parse time on every visit exactly like an external file would, and it never caches.
Apps that left code behind
Uninstalling an app removes its embeds and its ScriptTags, but not code it wrote into theme.liquid or a snippet. In the report that shows up as a third-party host with no entry in the apps-identified list beside it. Search the theme code for the hostname, and add the check to your Shopify SEO audit.
Bytes are uncompressed, and some are unknown
Sizes come from a HEAD request per external script, capped at 30 per run, asking for the uncompressed length. A host that refuses HEAD gets one bounded GET; if that fails too the script says unknown and stays out of the totals. Inline sizes are exact.
What to do next
Six steps take a report to a lighter page. The order is deliberate: the two groups you control come first, the loading flags second, and the deprecation clean-up last because it has a date attached.
- 01
Pick a product page, not the homepage
Product and collection templates carry the reviews, upsell, size-chart and wishlist blocks that homepages skip, and they are the pages that rank. Paste the full URL including https:// and run the check. One URL per run; the report reads that page's HTML only.
- 02
Read the four group counts first
Third-party origins and app scripts are the two you can change. Theme assets you can edit but usually need. Platform scripts are Shopify's own checkout, analytics and pixel code, identical on every store, and the report lists them so you stop trying to remove them.
- 03
Match each third-party host to an app or a person
Every host in the third-party list came from somewhere: an app embed, a tag pasted into theme.liquid, or a tag manager. The apps-identified list names the app embeds. A host with no app beside it is either a manual tag or a leftover from an uninstalled app.
- 04
Check the loading flags on the five heaviest
A large script marked blocking has neither async nor defer, so the browser stops parsing the page until it downloads. That is the single attribute most likely to move LCP. Ask the app vendor for a deferred embed, or move a manual tag to the end of the body with defer.
- 05
Turn off what the page does not use
In Online Store, Themes, Customize, open App embeds and switch off any embed the page does not need. Uninstall apps you no longer use rather than just closing them. Then rerun the check: the app group count and the third-party host list should both fall.
- 06
Migrate anything in the legacy ScriptTag list
Scripts under Legacy ScriptTag API are injected by apps using an API Shopify is removing. Storefront script tags stop running on March 1, 2027. Ask each vendor whether their app has moved to a theme app extension, and replace the ones that have not.
Before adding anything back, check the app against the Shopify SEO apps roundup, which notes what each one loads on the storefront, and keep the script count on your Shopify SEO checklist so it is rechecked after every app install. The page speed entry explains how the metrics relate to what you removed.
See which slow pages are costing rankings
Removing a script from the theme changes every page at once, and a product page earning 1,200 clicks a month deserves the fix before a page earning none. CrawlRaven's 200-point audit ranks speed findings by ranking impact, joined with Search Console and GA4 into one ranked plan. Free plan for 1 site.
What this tool reports
Four origin groups
Theme assets, Shopify platform, app scripts and third-party hosts, with external and inline counts each
Loading flags
async, defer and type=module on every script, plus a blocking flag for external scripts with none
Byte sizes
HEAD request per external script, up to 30 per run, third-party and app scripts first; inline block lengths are exact
Five heaviest scripts
Across sized external files and inline blocks, with the group each belongs to
Apps identified
Every app embed block and theme app extension named in the HTML, with its script count
Legacy ScriptTag list
The URLs Shopify's loader injects on window load, from apps still on the deprecated API
Hosts named in inline code
Domains inline scripts mention that no tag loads, the likely runtime injections
Shopify detection
Reads /cdn/shop/ paths and the powered-by header, and says so when a page is not Shopify
One page, one HTML response
Frequently asked questions
What does the Shopify App Script Checker measure?
It reads the HTML of one storefront page and lists every script tag, grouped by origin: theme assets, Shopify platform code, app scripts and third-party hosts. For each external script it records async, defer and module flags and asks the server for a byte size, up to 30 lookups per run.
Does this tool measure page speed or Core Web Vitals?
No. It counts and sizes the JavaScript a page ships, which is the input to speed, not the result. LCP, INP and CLS come from a rendered load, which this scan does not do. Use PageSpeed Insights or Search Console's Core Web Vitals report for the metrics, and this tool for the why.
Why does the count differ from what I see in browser DevTools?
DevTools shows every request a rendered page makes, including scripts that other scripts injected after load. This checker reads the server's HTML without running any of it, so a tag manager's children and app loaders' downstream files are missing. The legacy ScriptTag list is the one runtime injection it can see, because Shopify prints the URLs.
How does it tell an app script from a theme script?
By path. Theme assets live under /cdn/shop/t/<id>/assets/. Theme app extension files live under /extensions/<uuid>/ on Shopify's CDN, and app embed blocks are wrapped in BEGIN app block comments that name the app. Shopify's own code sits under /cdn/shopifycloud/ and /cdn/wpm/. Anything else is a third-party host.
What is a theme app extension?
A theme app extension is the bundle of app blocks, app embed blocks, assets and snippets an app ships so it can render inside a theme without editing theme code. Shopify hosts the assets on its CDN and merchants switch each embed on or off in the theme editor. It replaced script tags in 2021.
Are Shopify ScriptTags still supported?
They are being removed. Shopify's deprecation page states apps cannot create or update script tags after October 1, 2026, and script tags stop running on storefronts on March 1, 2027. Order status page script tags stopped earlier. Apps are expected to move to app embed blocks or web pixels.
Can I remove the Shopify platform scripts?
No. The platform group holds Shopify's checkout preloads, Shop Pay, the web pixels manager, Shopify analytics and the performance kit, all written by content_for_header. Every store on the platform loads them and there is no theme setting that drops them. Spend the effort on the app and third-party groups instead.
What do the async and defer flags mean?
Both stop a script from pausing HTML parsing while it downloads. async runs the script as soon as it arrives, in any order; defer runs it after parsing finishes, in document order. type=module scripts defer by default. An external script with none of these is marked blocking, and those are the first to fix.
Why is a script's size shown as unknown?
The host did not answer a HEAD request with a Content-Length, and the fallback GET either failed or was blocked. Some CDNs refuse HEAD, some require a browser user agent, and some only stream. The script is still counted and grouped; only its byte figure is missing from the totals.
How do I find scripts left behind by an uninstalled app?
Look for a third-party host with no app named beside it in the apps-identified list. Uninstalling an app removes its embeds and ScriptTags, but code an app wrote into theme.liquid or a snippet stays. Search the theme code for the host name, remove the include, and rerun the check.
Does the checker work on non-Shopify sites?
It runs, but with a warning. Without /cdn/shop/ paths or a powered-by: Shopify header the theme, app and platform groups have nothing to match, so most scripts land under site scripts or third-party origins. The counts, flags, sizes and host list are still accurate for any HTML page.
What are the limits per run?
One URL per run, the first 150 executable script tags, and 30 byte-size lookups, with third-party and app scripts sized before theme and platform ones. Pages over 5 MB of HTML are cut at that point. Free checks are limited per day; the counter under the input shows what is left.
Other crawl and indexing tools
Website URL Extractor
Crawl any website and download every URL it links to as CSV, TXT, or JSON. Works straight from the live site, no sitemap required.
Use toolRedirect Chain Checker
Trace every redirect hop with status codes and response times. Detect loops, long chains, protocol downgrades, and 302 misuse.
Use toolPage Indexability Checker
Find out why a page is not indexed. Checks status codes, noindex tags and X-Robots-Tag headers, robots.txt rules, canonicals, sitemap membership, and rendered content.
Use toolBroken Link Checker
Find links that no longer work, internal and external together. Checks up to 50 links on a page for 404 errors, redirects, and timeouts.
Use toolExternal Link Checker
Audit who a page links out to and on what terms. Destinations grouped by domain, with rel nofollow, sponsored and ugc, new-tab safety, and live status.
Use toolInternal Link Analyzer
See which internal links a page makes in its own writing and which come from the template, grouped by destination, with anchor text, nofollow and live status.
Use toolRobots.txt Tester
Analyze robots.txt to see which AI crawlers and search engines are blocked, find sitemaps, and identify access issues.
Use toolRobots.txt Generator
Build a correct robots.txt from presets for WordPress, ecommerce, and AI crawlers. Decide which bots to allow, add your sitemap, copy the file.
Use toolllms.txt Generator
Build a valid llms.txt from your own pages: the H1, blockquote summary and H2 link sections the proposal specifies, checked for relative URLs and duplicates.
Use toolHTTP Header Checker
Read every response header a URL returns, with the redirect chain timed hop by hop and X-Robots-Tag, header canonicals and caching gaps called out.
Use toolShopify robots.txt.liquid Generator
Build a robots.txt.liquid template that keeps Shopify's default rules in the Liquid loop and adds blocks for tag pages, vendor and type collections, filter parameters and AI crawlers.
Use toolRead up on crawling and indexing
A tool tells you what is wrong. These explain what to do about it.
The Crawl Stats Report: What Googlebot Actually Did on Your Site for 90 Days
Read guideShopify Redirects: How to Set Up 301s Without Losing the Rankings You Have
Read guideSearch Console's Discover Report: No Queries, No Position, and Traffic That Arrives in Spikes
Read guideTerms this tool checks
- Page Speed
Page speed refers to how quickly a web page loads and becomes interactive, encompassing metrics like TTFB (Time to First Byte), FCP, LCP, and total load time.
- Core Web Vitals
Core Web Vitals are a set of specific page experience metrics that Google uses as ranking signals: LCP (Largest Contentful Paint) measuring loading speed, INP (Interaction to Next Paint) measuring interactivity, and CLS (Cumulative Layout Shift) measuring visual stability.
Find the slow pages that are costing rankings
CrawlRaven is Search Console, GA4 and a 200-point crawl joined into one ranked plan. Speed findings are ranked by ranking impact, so the product page losing clicks gets fixed before the one nobody visits. Free plan for 1 site, no credit card.