A Better Help Doc
Written and maintained for the brands and agencies who are conducting a site migration. Especially if you are a small team who needs to make every hour count. This guide helps you build a strategy to accurately complete 301 redirects if you’re migrating to Shopify. Specifically, this document can help you if you’re:
- Migrating from Wordpress
- Migrating from Magento
- Migrating from Salesforce
- Migrating from Sitecore
- Migration from BigCommerce
- Migrating from Webflow
- Migrating from a homegrown PHP site
If you’re undertaking a project that includes complex 301 redirect mappings and need a team who lives and breathes this specific type of work, contact us.
Shopify’s URL Redirect Logic: Overview
The official Shopify Help Doc for URL redirects is found here. It’s a streamlined document with general guidelines a Shopify store manager can reference to add individual and bulk 301 redirects. It lacks specifics on the types of URLs a Shopify store can support natively, but this report is intended to fill the gaps.
Summarized Findings of Shopify’s URL Redirect Functionality
- Shopify’s URL redirect logic is very robust.
- From our test of 100 different URL string formats, Shopify functionally supported 99 out of 100 of the types.
- The native system does not support wildcards for URL redirects.
- Updating existing URL redirect paths was easy with the import tool, as long as you follow Shopify’s undocumented rules
- Limits exist with total number of redirects Shopify & ShopifyPlus stores will manage.
- Limits exist with the total number of characters for a URL redirect string.
- You cannot create 301 redirect chains, thankfully. (Corrected in the 2026 retest. The safeguard checks one direction only.)
- Many exceptions and rules exist for URLs with parameters.
- The interface for URL redirect management is user-friendly, but can benefit from more details.
- Tests did not examine redirect options available for Hydrogen and Oxygen.
- We give Shopify’s current URL redirect system a helpfulness score of 85%.
The rating was lowered by 5% for no wildcard support, by 1% for the single URL string type it did not support, by 2% for URL character-length limits, by 3% for the odd behavior with parameterized URLs, and by 4% for essential information management details missing from the redirect UX.
Testing was conducted on June 19, 2024.
Every claim here was rechecked against a live Shopify standard plan store, through the Admin GraphQL API and against real storefront requests. Most of the 2024 findings held. Nine did not, and two of those reverse what we published: the chain safeguard checks a single direction and the order you create records in decides whether a chain forms, and a redirect on /services fires while anything beneath it returns a 404.
The 2024 findings stay where they are. Each correction is marked at the claim it applies to, so anyone who acted on the original can see what moved.
Our Redirect Testing Methodology
We wanted to answer a few questions with our tests, to help avoid pitfalls with Shopify’s 301 redirect rules:
- What characters or string combinations does the URL redirect system not support?
- Are there any limits with URL string length?
- Is there a maximum number of records for bulk imports?
- Does the system support wildcard redirects?
- Is there any auto-formatting or conversion of strings after import that changes the original data?
For reference, here is our full list of URLs we used to test these different conditions. Tests were conducted on a Shopify standard plan (not ShopifyPlus).
11 Findings to Help with Shopify Redirects
Shopify Does Not Play Nice With These URL String Types
The list of URL string formats that Shopify could not support is short, with only one type of string it could not ingest. Strings with a semicolon character after the equals operator, such as:
/page?param=;semicolon
What’s noteworthy with this string is that Shopify’s system will convert the semicolon special character into the URL encoded value as follows in the redirect table:
/page?param=%3Bsemicolon
When you enter the unencoded URL string into the address bar of a browser, it will return a 404 error.
/page?param=;semicolon
/page?param=%3Bsemicolon
This functionality deviates from other special character handling. If a URL string with unencoded characters is entered in the address bar, such as the right brace character:
/page?param=}
Shopify will automatically encode it when the URL request is received and no 404 error will occur.
/page%7Drightbrace
Additionally noteworthy, other variations of a URL string with an unencoded semicolon validate in Shopify’s redirect system such as:
/page;semicolon
The data suggests that the 404 error is only triggered when an unencoded semicolon occurs after the equals operator.
The 404 is confirmed, but "could not ingest" is not what happens. Shopify accepts the record and stores it with the semicolon percent encoded as %3b. The mismatch happens at request time, because an incoming URL carrying a raw semicolon never matches the encoded record.
Requesting the encoded form returns a 301 as normal. Where you control the inbound links, percent encoding the semicolon resolves it. Where the raw semicolon arrives from external links you do not control, this format cannot be redirected reliably.
No Support for Wildcard Redirects from Shopify
Wildcard redirects are still on the wish list of many Shopify users. Their support forums are inundated with requests for this feature. To date Shopify has remained silent on where this would fall on the product roadmap.
For the time being, website owners planning a move to Shopify should understand that native Shopify & ShopifyPlus do not offer this option.
What are wildcard redirects?
Wildcard redirects are a type of URL redirection that allows you to redirect multiple URLs that match a specific pattern to a single destination. This is particularly useful when migrating a website, reorganizing content, or managing large numbers of similar URLs. Instead of setting up individual redirects for each URL, you use a wildcard character (usually *) to represent any sequence of characters.
Suppose you are restructuring your blog and moving all posts from the /blog/ directory to /articles/. Instead of setting up individual redirects for each blog post, you can use a wildcard redirect:
From: /blog/*
To: /articles/*
This wildcard redirect will automatically map:
/blog/post1 to /articles/post1
/blog/post2 to /articles/post2
/blog/post3 to /articles/post3
This simplifies the redirection process and ensures all URLs under /blog/ are seamlessly redirected to their new location under /articles/. As of the date of this article, Shopify and ShopifyPlus default stores do not include this capability without app support.
Still no wildcard support, and the retest found the part that costs people real traffic. Shopify accepts wildcard syntax without complaint. A record created as /old-blog/* saves, appears in the redirect table, and reports no error. The asterisk is stored as a literal character, so the only URL it will ever match is one that literally contains an asterisk.
That is worse than an outright rejection, because nothing signals the failure until real traffic starts returning 404s. Expand any wildcards in your redirect spreadsheet to explicit paths before you import it.
Shopify Does Its Best to Avoid Creating Redirect Chains
There is a nice safeguard in the Shopify redirect table that prevents you from creating redirecting chains. If you try to create a redirect to a page that is already a value in the “Redirect from” field, you will get an error.
In this test the URL records we tried to create were as follows, which was not allowed:
/BOTH redirects to /SHORT/SHORT redirects to /homepage
A safeguard exists, and it is narrower than we described. It checks one direction, and a live two hop chain was created past it during the retest.
Shopify rejects a redirect whose destination is already the source of another redirect, with Target can't redirect to another redirect. It rejects a redirect pointing at itself, with Target can't be the same as path, and it blocks direct two way loops.
It does not check the reverse. Create /a to /b while nothing exists at /b, then later create /b to /c, and both are accepted. Shopify never revisits the first record, and you now have a live chain:
GET /a
301 to /b
301 to /
final: 200, 2 hopsCreation order alone decides whether a chain forms. Bulk imports apply rows in file order, and migration spreadsheets are rarely sorted to avoid this, so the safeguard is not something to plan around. After any large import, sample your redirects and count the hops:
curl -sIL https://yourstore.com/old-path -o /dev/null -w "hops: %{num_redirects}\n"Anything above 1 is a chain.
What are Redirect Chains?
Redirect chains occur when a URL is redirected to another URL, which in turn redirects to yet another URL, creating a sequence or “chain” of redirects. This can happen unintentionally when multiple redirects are set up over time without proper management.
Redirect chains are problematic because they can slow down page load times, negatively impact SEO, and create a poor user experience. Each additional redirect adds latency as the browser must follow each step in the chain before reaching the final destination.
For example, if you have the following redirects set up:
/old-page redirects to /new-page
/new-page redirects to /latest-page
When a user visits /old-page, they are first redirected to /new-page, and then immediately redirected again to /latest-page, resulting in a redirect chain.
New Rules to Follow When Setting up Redirects on Shopify
Our biggest discovery in our tests is that Shopify’s documentation is out of date. According to Shopify, if you’re trying to redirect anything that starts with these reserved prefixes, your redirect rules will not be created:
/apps
/application
/cart
/carts
/orders
/services
/products
/collections
/collections/all
We found that not to be true.
/apps/application/carts/orders/services/cart/people
Cart was the exception. It is reserved on its own, and works once a subdirectory follows it.
/cart/products/collections/collections/all
/cart/people/carts/people/products/people/collections/people
/cart/products/collections/collections/all
The observations above hold. The explanation does not, and the real rule covers far more ground than a list of four prefixes.
A real storefront route always beats a redirect. Where a page genuinely exists at a URL, Shopify serves the page and ignores the redirect. The record is accepted, it sits in your redirect table, and it does nothing. No error, no warning.
The prefix is not the variable. Existence of a route is. A redirect placed on a live product URL was accepted and silently ignored, while the identical prefix with a handle that does not exist returned a 301:
/products/ai-skillset-package-001 -> 200, the product page
/products/zz20260727 -> 301, the redirect firesSo treat the list above as examples rather than as the rule. It also covers every live product, collection, page and blog article on your store. A redirect on a published product URL is inert until that product stops resolving.
For a migration this makes sequence matter. Unpublish or delete the old resource first, then confirm the redirect fires. Create it while the page is still live and it will look like nothing happened.
/services is the exception, and it runs the opposite way. A redirect on /services itself returns a 301. A redirect on anything beneath it, such as /services/consulting, returns a 404 even though the record saves without complaint. That was retested four times across about 45 seconds to rule out propagation lag, with the record present throughout. Every other prefix in this group worked with subdirectories. The likely cause is that Shopify routes /services/* internally for app proxies and system endpoints, so those requests never reach the redirect table, though we did not verify the mechanism directly.
Anyone migrating a site with a /services/ section should know that none of those redirects will fire. Remap them to a different path structure, or handle them at your DNS or proxy layer.
Creating and Updating URL Redirects is Easy on Shopify
The creation of a new redirect is simple on Shopify. They give users two options:
- Individual URL redirect creation, one at a time
- Bulk redirect creation, through a CSV file - here’s the latest template for that import.
When adding URLs to Shopify’s system, users can input relative URL paths, no top level domain, for the origin (from) and absolute or relative URL paths in the destination (to). Example:
/example_product.php
Creating Individual URL Redirects
The redirect rules Shopify has in place will not allow you to create the same URL redirect twice when using the individual redirect interface.
Once a URL is in the ‘Redirect from’ table listing, if you try to add it again you will get an error.
If you want to update the individual URL record, you need to find it in the redirect table, or use the bulk import method. If a URL that already exists is included in a bulk import file, the record’s ‘Redirect to’ field will be updated with the value from the CSV file.
Our advice is to always import redirects in manageable, efficient batches. For example, if you have 10,000 URL redirects, import 1,000 at a time and check them if you have the time. It’s better to catch errors in smaller datasets than hunting them down in bigger ones.
Be Thoughtful with Bulk URL Redirects in Shopify
To create bulk redirects, populate the CSV file with the headers Shopify requires, create the 1:1 mappings, make sure all URLs are formatted as relative paths. If you create a file with absolute paths in either the the ‘Redirect from’ or ‘Redirect to’ fields, Shopify will take matters into their own hands. Here’s a few scenarios:
https://www.wislr.com/path/to/resource%20with
/path/to/resource%20with
www.wislr.com/unicode/test?value=%E2%9C%93%20co.wislr.com/mix/of%20encoded
/www.wislr.com/unicode/test?value=%E2%9C%93%20/co.wislr.com/mix/of%20encoded
wislr.com/nested/directory/structure?param1=value1
/wislr.com/nested/directory/structure?param1=value1
The takeaway is to double-check your import file before you use it. Otherwise you will create URL redirect rules that don’t operate in the manner you need them to.
If a redirect record already exists in the table and the same values is included in the import file, Shopify will update the record with the most current data from the import file. This is extremely helpful in our opinion, so long as you want that record to update. All the more reason to double-check the data.
Our advice is to always import redirects in manageable, efficient batches. For example, if you have 10,000 URL redirects, import 1,000 at a time and check them if you have the time. It’s better to catch errors in smaller datasets than hunting them down in bigger ones.
Shopify does not enforce a 1,000 row ceiling per file. A single 1,051 row import ran through with zero failures in 48 seconds, which works out to roughly 1,300 rows per minute.
Batches of around 1,000 are still sensible, for a different reason than a hard limit. Smaller files fail more legibly. If a 20,000 row import goes wrong you have far less idea which rows caused it than if you had run twenty files and watched the counts.
Read createdCount, updatedCount and failedCount after each import. A non zero failedCount is the only signal you get that rows were dropped.
The duplicate behavior described above was confirmed exactly as written. A path already in the redirect table has its destination overwritten and is reported under updatedCount, keeping its original record id. That makes a CSV import safe to rerun, which is genuinely useful mid migration. It also means a stale spreadsheet will quietly overwrite corrections you made by hand since the last import.
Have us build the redirect map.
We have mapped redirects through more than 100 migrations, including a 27,000 URL move onto Shopify Plus. We build the file and validate it against every limit on this page before it imports. After cutover we read the live responses ourselves rather than trusting what the redirect table says.
Shopify’s Limit on URL Redirect Records
All good things have their limit, and Shopify’s redirect rules are no different. There’s two thresholds for URL redirects.
Shopify Plans (not Plus):
Maximum 100,000 URL redirects
ShopifyPlus Plans:
Maximum 20,000,000 redirects
We have not tested these limits, that would be wild! These are the current documented specifications for the platform. Please keep them in mind as you plan your redirects and prioritize the top URLs for traffic and revenue. To the best of our knowledge Shopify does not increase these limits, despite constant pleading from the support forums.
Shopify’s Limit on Characters in URLs
This is where things get spicy with Shopify’s redirect system. Official guidelines from Shopify do not specify strict character limits.
To validate the limits of URL characters for a redirect we first built and tried to import very long strings. We started with a 2,000 character-long URL, since browsers can handle URI requests up to 2,083 characters in length. Here’s the darling in all her beauty:
/2000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBcccccccccccccccccccccccccccccccccccccccccccccccccccDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Our initial method was to import a 2,000 character URL using the bulk redirect template and that’s when Shopify’s alarms were triggered. The threshold we officially discovered was a 1,024 character limit for URL redirect strings, inclusive of the forward slash prefix ‘/’.
- Passed 300 character URL
- Passed 600 character URL
- Passed 1,000 character URL
- Failed 2,000 character URL
Some Important and Undocumented Redirect Rules to Understand About Shopify
Shopify will normalize alphabetical characters in your URL strings. This means, whether you put in a capital or lowercase letter, it will serve URL request for those different patterns in the same way. The following URLs will all go to the same page, even if individual records exist:
/CASE/TEST.html
/case/test.html
/Case/Test.html
The lowercase string with take priority over the others:
/case/test.html
In our tests, even though there are two unique records for “Redirect from” with different values for “Redirect to”, the /about.html page will always be served for both records:
#1
/Case/Test.html [redirect to] /homepage
#2
/case/test.html [redirect to] /about.html
It’s intriguing and potentially vexing that Shopify will allow you to enter all of these unique values in the redirect table and only serve one of them. We advise you review your data carefully if you feel your URL taxonomy could fall into these patterns before importing into Shopify.
You Can Use Absolute URL Paths for Shopify Redirects
Absolute URL paths for your redirects are okay our test found, if they are in the “Redirects to” field. They can be to any URL you desire. Here is one example where a URL path will redirect to a LinkedIn profile when requested:
[Redirect from]
/Case/Test.html
[Redirect to]
https://www.linkedin.com/wislr
Also, in the “Redirect to” field Shopify does not remove top level domains, even if it’s for your own Shopify store.
Parameterized URLs
It our tests Shopify preserved URLs with parameterized URLs, with some exceptions. If you have URLs that have been indexed with many unique parameterized URL strings, then those unique strings can be added to Shopify’s redirects tables and go to unique destinations. We did this test with a common taxonomy for these type of URLs, UTM parameters. For example:
This URL string is in the redirect table’s “Redirect from” field and went to it’s intended destination:
/how-is-pkl?utm_campaign=301s+in+2024&utm_content=blue&utm_id=3012024&utm_medium=display&utm_source=google&utm_term=redirects
We modified the URL string and removed the last parameter ‘&utm_term=redirects’, which created a 404:
/how-is-pkl?utm_campaign=301s+in+2024&utm_content=blue&utm_id=3012024&utm_medium=display&utm_source=google
This behavior was reproduced in other tests with different parameters as values, which confirmed that Shopify treats parameterized URLs has literal strings. They do not concatenate the URL down to the base URL if you remove a parameter from a redirect URL, so long as the URL does not exist on the Shopify site.
To further confirm this we pointed a URL to itself, which by default Shopify does not allow. You would get this message:
This entry is allowed when the parameters are in the “Redirect from” field. It does not constitute a redirect loop, but based on behavior in the browser, our test showed that Shopify ignores this record. When the “Redirect from” URL is requested, Shopify serves the full parameterized URL string, not the root page as expected in the table:
This entry is allowed but Shopify will not append the parameters to the page that loads, as the rule expects. They will only load the root URL. Parameters are never added to the URL that loads:
Our final observation about URLs with parameters is that Shopify will rewrite the data you give it in some cases. Yes, Shopify will rewrite the URL data you give it for some parameters.
Here are examples where our tests found this pattern.
Original redirect data ingested by Shopify:
/test?name=John&Doe
Shopify rewrote the strong to have ‘Doe’ be the first parameter attribute in the string:
/test?Doe&name=John
Original redirect data ingested by Shopify:
/user?name=John&age=30&active=true
Shopify rewrote the string to have a new order for the parameters listed:
/user?active=true&age=30&name=John
The tests we ran suggests that Shopify is trying to put the parameters in alphabetical order. We wondered if this was a bug since we have determined that Shopify treats parametrized URLs as literal strings, so why undermine that rule by rewriting the parameter order. Currently, you will never get URL strings with multiple parameter values to retain their structure. This could have big implications for some Content Management Systems.
Three corrections to this section.
Parameters on the incoming request are carried through to the destination. The original wording says they are never added to the URL that loads, and that is only true of the parameterized source paths described above. Where the redirect's source path carries no parameters of its own, whatever arrives on the request is appended:
GET /old-page -> 301 to /new-page
GET /old-page?utm_source=x -> 301 to /new-page?utm_source=xRedirects will not strip parameters for you. Removing them has to happen in a layer above Shopify.
The rewrite lowercases as well as reorders. The worked example above keeps its capitals, and Shopify does not. A path submitted as /test?name=John&Doe is stored as /test?doe&name=john. Values are lowercased along with the keys, so a redirect table compared against the source spreadsheet will look like the import corrupted the data.
Matching is not literal string comparison. Shopify normalizes both the stored record and the incoming request before comparing them, so capitalization and parameter order do not matter. Against a record stored as /page?doe&name=john, all of ?name=John&Doe, ?Doe&name=John and ?name=john&doe return a 301.
What does matter is which parameters are present. Every parameter in the stored path has to appear in the request. Drop one and you get a 404 rather than a partial match, so the original point stands: a parameterized redirect fires only for that exact combination of parameters.
Update to Shopify’s URL Redirect UX is Needed
During our extensive use of Shopify’s redirect tool, we found ourselves appreciating some elements and missing others.
We appreciate these features:
- Bulk redirect import buttons and functionality
- Filtering and fast search for URL taxonomy
- Export of URLs
- Ease to create a single URL
We found the tool lacks these data points and functionality:
- Total count of URLs imported
- Easier way to copy and paste more than one URL into the system. If you add more than one URL at a time, you have to use the import document. One use case where copy / paste would be helpful is if a set of URLs were all intended to point to the same destination.
Importing Is Fast, Undoing an Import Is Not
Added from the 27 July 2026 retest.
Creating redirects in bulk is quick. Removing them in bulk is not, and the gap is wide enough to change how you plan an import.
| Operation | Method | Observed |
|---|---|---|
| Create 1,051 redirects | CSV import, single file | 48 seconds |
| Delete 1,051 redirects | urlRedirectDelete, one at a time |
226 seconds |
The fast bulk delete mutations are gated. urlRedirectBulkDeleteBySearch, urlRedirectBulkDeleteByIds and urlRedirectBulkDeleteAll all require the write_online_store_navigation scope and an active user session. An app authenticating with client credentials, which is how most migration scripts run, cannot call them and is left deleting one record at a time.
Plan your imports as though they are difficult to reverse, because they are. Validate the file on a development store first, or import in tranches you are willing to unwind by hand. Do not push a 50,000 row file you have not tested on the assumption that you can roll it back quickly.
CSV Import and the Admin API Handle Duplicates Differently
Added from the 27 July 2026 retest.
This guide is written around the CSV workflow, where a duplicate path updates the existing record. The API does the opposite:
create /existing-path -> /pages/about
(where /existing-path already redirects to /)
REJECTED: "Path has already been taken"
Anyone porting a CSV workflow to the Admin API has to query for the existing record and call urlRedirectUpdate, or delete and recreate. A straight port of import logic will fail on every path that already exists.
How to Test Your Shopify Redirects After Launch
Everything above describes what Shopify will accept. None of it tells you whether the redirects you imported are actually working on the live store, and that is a different question. A redirect can import cleanly, appear in the admin, and still not do what you expected once a theme, an app, or a proxy is in the path.
Test from outside the store rather than by clicking around in a browser, because a browser hides the thing you need to see: the status code. Request the old URL and read the response headers.
curl -sIL https://yourstore.example/old-product-url
Read three things in the output:
- The status code on the first hop. You want
301. A302is temporary and passes value differently, which matters when the whole point is a permanent move. - The number of hops. Each
HTTP/line in the output is one hop. Two or more means you built a chain, and the fix is to repoint the original source at the final destination rather than leaving the middle step in place. - The final status. The last line should be
200. A redirect that ends in a404is worse than no redirect at all, because it looks handled in your spreadsheet.
Then test the shapes that are easy to forget. Run the same check on a URL carrying a tracking parameter to confirm the query string survives to the destination, on the apex domain as well as www, and over plain http rather than only https. We tested exactly this on a live store and the parameter carried through to the target intact, but the point is to verify it on your store rather than trust a general answer, because a theme or an app can change the outcome.
One behaviour worth knowing before you panic: after you change or delete a redirect, a Shopify edge node can keep serving the old response for around thirty seconds while a cache-busted version of the same URL already returns the new one. Give it a minute and re-test with a unique query string appended before concluding the redirect did not take.
For the full sequence around a migration rather than a single redirect, work through the website migration checklist, which covers the mapping, launch day, and post-launch monitoring this fits into.
In Conclusion
The system Shopify has for managing 301 redirects is good for most businesses, but is not yet Enterprise level. With time we hope they evolve to include wildcard redirects and more redirect records for their standard and plus plans. The ability to use their redirect system and the various types of URL formats it supports leaves us rating them with a strong helpfulness score.
If you’re undertaking a project that includes complex 301 redirect mappings and need a team who lives and breathes this specific type of work, contact us.
Frequently Asked Questions
Who is WISLR’s Shopify URL Redirects knowledge-base intended to help?
Our knowledge base primarily assists brands and agencies conducting site migrations to Shopify. It’s especially valuable for small teams who need to make every hour count, helping clients match and complete up to 100,000 URL redirects efficiently.
Does Shopify have an official support document for URL redirects?
Yes, Shopify maintains an official help document for URL redirects at help.shopify.com. While it provides general guidelines for adding individual and bulk 301 redirects, our guide supplements it with detailed specifications about URL types and platform limitations.
What are the URL strings Shopify does not support?
Shopify only has one unsupported URL string format: strings with an unencoded semicolon character after the equals operator (e.g., /page?param=;semicolon). All other URL formats, including encoded semicolons and semicolons in other positions, are supported.
Does Shopify support redirects using wildcards or regex?
No, Shopify does not currently support wildcard redirects or regex patterns in their native redirect system. This limitation exists for both standard Shopify and Shopify Plus stores.
What are wildcard redirects?
Wildcard redirects allow you to redirect multiple URLs matching a specific pattern to a single destination. For example, redirecting all URLs under /blog/* to /articles/*. While this feature is commonly requested, it’s not currently available in Shopify’s native functionality.
Can Shopify avoid creating redirect chains?
Yes, Shopify has built-in safeguards to prevent redirect chains. The system will not allow you to create a redirect to a URL that is already being redirected elsewhere.
What are redirect chains?
Redirect chains occur when URLs redirect through multiple steps before reaching the final destination (e.g., A→B→C). These chains can slow down page loads and impact SEO performance. Shopify’s system helps prevent these by design.
Is it easy to create and update URL redirects on Shopify?
Yes, Shopify provides two straightforward methods: individual URL redirect creation through their interface and bulk import via CSV file. Both methods support relative and absolute URL paths.
How do you create bulk URL redirects in Shopify?
Bulk redirects can be created using Shopify’s CSV import tool. We recommend importing in batches of 1,000 for easier error checking and management. A template for the import is available here.
Does Shopify have a maximum limit on URL redirection records?
Yes. Standard Shopify plans are limited to 100,000 URL redirects, while Shopify Plus stores can handle up to 20,000,000 redirects. These limits are fixed and cannot be increased.
Does Shopify have redirect character count limits?
Yes, Shopify enforces a 1,024 character limit for URL redirect strings, including the forward slash prefix (’/’). URLs exceeding this length will not be accepted by the system.
Is there a tool to validate URLs for Shopify compatibility?
While Shopify doesn’t provide an official validation tool, our comprehensive testing has shown that 99% of standard URL formats are supported. The main consideration is the 1,024 character limit and avoiding unencoded semicolons after equals operators.