Action RequiredPlatform

When you replace or delete a file,
the CDN URL is no longer auto-purged

Starting April 7, 2026, replacing or deleting a file in the Shopify admin no longercdn.shopify.com/... clears the cache immediately. Stale content keeps being served until the TTL expires. The fix is to dynamically output a versioned URL (?v=...).

On this page
  1. What changed (in 30 seconds)
  2. How it works: behavior on replace (Before / After)
  3. Why this change was made
  4. Safe patterns vs. broken patterns
  5. Fix: three implementation patterns
  6. 5 points engineers need to know
  7. 3 use cases you can apply at work
  8. One-line summary for proposals

1What changed

Previously, when you replaced or deleted a file in the admin, Shopify would actively purge the URL on the CDN.
Starting April 7, 2026, that automatic purge no longer happens. The cache for the same URLkeeps serving the old content until the TTL (Time To Live) expires.

Before: replace = instant purge

When you replaced a file, Shopify automatically cdn.shopify.com/... cleared the cache, and the new content was served immediately.

From 2026/4/7: no purge

Replacing or deleting a file no longer purges the same URL. The old content remains until the TTL expires, so there is a window where the change is not visible.

Action Required : cdn.shopify.com/... URLs that are hardcodedwill keep returning the old content even after the file is replaced. Migrating to a dynamic pattern is recommended.

2How it works: behavior on replace (Before / After)

BEFORE(~2026/4/6) Replace / delete file Auto-purge the CDN Cache purge Serve new content Immediate update AFTER(2026/4/7~) File replacement /deletion No purge Same URL as before Serves old content Continues until TTL expires If ?v=... is output, new URL = instant update
Key point : The key is "changing the URL." When a file is updated, Shopify's URL helpers ?v=... re-append the version parameter with the latest value. Once the URL changes, the CDN treats it as a different resource and serves the new content immediately.

3Why this change was made

Reducing CDN purge volume

Stated in the article: the goal is to reduce the total volume of purge operations that occurred with every file replacement.

Improved consistency across edge providers

Stated in the article: the goal is to improve delivery consistency across multiple edge (CDN) providers.

Specific TTL durations and details on which file types are affected are not documentedin the article. If you need to know the exact behavior, check the actual delivery responses (cache headers).

4Safe patterns vs. broken patterns

How it's referencedBehavior after replacementVerdict
In a theme, file_url / image_url / asset_url
referenced via a Liquid filter		 The latest ?v=... -stamped URL is output, and the new content is served Safe
Inserted into a product via the native Media uploader
Upload images and videos directly		 Shopify manages the versioned reference → updates are reflected Safe
URL fetched at request time by an app or external integration
Fetched each time from the Admin GraphQL / Storefront API		 Always fetches the latest URL → updates are reflected Safe
In a product description or blog post, <img src="cdn.shopify.com/..."> Pasting directly Even when replaced keeps returning the original content broken
In theme code cdn.shopify.com/... hard-coded Even when replaced keeps returning the original content broken
Fixed URLs printed on physical materials
Same applies when apps cache URLs		 Even when replaced keeps returning the original content broken

5Fix: three implementation patterns

1

Theme

Use the Liquid filter file_url / image_url / asset_url to render file references.

2

Products

In descriptions, <img> instead of pasting, insert images and videos via the native Media uploader.

3
API

Apps / external integrations

Do not cache URLs;at request timefetch from the Admin GraphQL API / Storefront API.

The shared goal across all methods isto always output the current versioned URL (?v=...). This way, every time a file is replaced, the URL updates and customers receive the latest content.

6Five points engineers should know

?v=...

1. The core fix is "changing the URL"

Lean toward a design where the cache key itself changes via a version parameter, ?v=... rather than purging. When the URL changes, the CDN treats it as new.

2. Hard-coding cdn.shopify.com is the landmine

Any place where a fixed URL is embedded in product descriptions, blogs, theme code, or printed materials will not update when the file is replaced. Inventory these.

GraphQL

3. Apps should not cache URLs

Implementations that store file URLs in a DB or cache in external integrations need review. Fetch from the Admin / Storefront API at request time.

4. Updates are not "instant" but TTL-dependent

Existing URLs that have not migrated to the dynamic pattern will keep returning the old content until the TTL expires. The specific TTL value is Not specified.

5. Migrate themes entirely to URL helpers

Standardize static asset and file references inside themes to go through file_url / image_url / asset_url . For new development—and for code reviews of existing themes—set up a mechanism (grep / linter) to detect hard-coded URLs to prevent incidents.

7Three use cases you can apply to your work

Stale image persists
USE CASE 1

Preventing "I replaced it but it isn't reflected" support tickets

Problem
If you operate by swapping campaign banners or product images under the same filename, after 4/7 the old image will keep being served, generating "the update isn't reflected" support tickets.
Action
Unify theme and product image references to URL helpers / native Media, and completely eliminate hard-coded cdn.shopify.com .
Outcome
Immediate reflection of replacements is guaranteed, reducing support workload and the risk of "publishing accidents."
Technical notes
Inventory existing themes and product descriptions by grepping for cdn.shopify.com . The explicit TTL value is not specified, so the timing of reflection needs to be verified by observing behavior.
App / API Fetch at request time Latest ?v= URL
USE CASE 2

Inventorying "URL caches" in external integrations and in-house apps

Problem
Integrations that store product image URLs in your own DB, caches, email delivery, PIM, ad feeds, etc. will keep serving the old image after a file swap.
Action
Stop storing URLs; redesign so that URLs are fetched from the Admin GraphQL API / Storefront API at request timefor delivery and display.
Outcome
Guarantees freshness of product visuals across all channels. Prevents lost opportunities and complaints caused by serving the wrong image.
Technical notes
Since fetch frequency will increase, design the API rate limits together with the response caching strategy (short-term caching on the query result side, not on the URL).
USE CASE 3

Building "hard-coded URL detection" into migrations and code reviews

Problem
In theme development and site migration projects, previously pasted cdn.shopify.com/... fixed URLs slip past review, leaving images that cannot be updated after release.
Action
Add "nocdn.shopify.com hard-coding → URL helpers required" to CI / code review checks and automate detection.
Outcome
Mechanically blocks the inclusion of non-replaceable assets before release. Improves the maintainability of deliverables.
Technical notes
Themes should use file_url / image_url / asset_url as a required replacement. Hardcoding <img> directly into product descriptions should also be banned by operational policy.

8One-line summary for proposals

"Starting 2026/4/7, replacing a file will no longer automatically purge the CDN, and old content will remain until the TTL expires.
The fix is to standardize on dynamic output of versioned URLs (?v=...). ―
For themes, use URL helpers; for products, use native Media; for apps, fetch from the API at request time. Hardcoded cdn.shopify.com should be audited immediately."