If your public Shopify app calls the Admin API and you have not turned on the IP allowlist yet, you are either already missing bulk operation calls (the November 12 deadline passed today) or eight days away from being delisted from the App Store. The fix is a Dev Dashboard toggle plus, separately, a [network_access] block in shopify.app.toml. Those two things are not the same control, and conflating them is the most common mistake I am seeing in community threads right now.
Key takeaways
- IP allowlisting for public apps became mandatory on November 5, 2026; bulk-operation enforcement hit on November 12 and general enforcement hits November 20, 2026 at 11:59 PM ET.
- The allowlist toggle lives in the Dev Dashboard, not in
shopify.app.toml. The toml file holds a separate[network_access]block for a different purpose. - Serverless apps (Vercel, Cloudflare Workers, AWS Lambda, etc.) can use ASN-based rules instead of static IPs, with up to 10 ASNs scoped to up to 10 countries.
- Shopify checks source IP against the allowlist on every GraphQL Admin API and REST Admin API request that uses your app's tokens.
- You can smoke-test
[network_access]declarations on a dev store with thenetwork_access_testingfeature preview before going to production. - Miss the deadline and the enforcement ratchets through four stages, ending with Admin API requests failing entirely on April 1, 2027.
Why this matters: the threat model
Admin API access tokens have always been the highest-value credential in a Shopify app's possession. A leaked token used to be reusable from any IP on the planet. The IP allowlist changes that: Shopify evaluates the source IP address of every covered request, and a valid token is simply rejected if it arrives from an address or network not on the list.
This is especially relevant for apps that handle payment data, fulfillment webhooks, or bulk catalog operations. I maintain a catalog sync app across stores with over 10,000 SKUs, and the bulk-operation pipeline is exactly the class of workload that hits the November 12 deadline first. If your app ran any bulkOperationRunQuery or bulkOperationRunMutation in the last 180 days, that codepath is in scope.
The enforcement timeline
| Date | What happens |
|---|---|
| November 12, 2026 | Bulk queries and mutations from non-allowlisted public apps are blocked |
| November 20, 2026 | App delisted from App Store, blocked from new installs, flagged in merchant Settings > Apps |
| January 15, 2027 | Merchants see an in-admin warning on existing installs |
| April 1, 2027 | All Admin API requests from non-allowlisted apps return errors |
Note: custom apps (installed via direct URL, not the App Store) are exempt from the mandate, though Shopify strongly recommends adding an allowlist for them too.
Two separate controls you need to understand
This is where most confusion comes from. Shopify shipped two related but independent features in its October-November 2026 security push:
1. The IP allowlist (Dev Dashboard)
An IP allowlist limits where your app's access tokens can be used. When enforcement is on, Shopify checks the source IP address of every GraphQL Admin API and REST Admin API request that uses your app's tokens.
This is configured entirely in the Dev Dashboard, under your app's Settings > IP allowlist > Manage. There is no shopify.app.toml representation of it yet. A developer in the community forums asked Shopify directly whether the IP allowlist can be part of shopify.app.toml and released with shopify app deploy. The answer from Shopify staff, as of this week, is that it cannot: [network_access] covers the hosts the app talks to, but the IP allowlist for the app's API credentials is a separate setting in the Dev Dashboard that decides which IPs can hit the Admin API with your tokens.
This distinction matters for CI/CD. The IP allowlist is a dashboard-managed configuration; deploying a new app version does not update it.
2. [network_access] in shopify.app.toml (declared hosts)
You can now declare your app's external hosts and servers in a new [network_access] section of shopify.app.toml. Normally Shopify warns customers when they navigate to a URL outside Shopify; declaring your external hosts skips this warning, letting you remove friction for trusted journeys. Declaring servers, meanwhile, helps Shopify spot suspicious activity and protect your app.
The block has two properties:
allowed_navigation_hosts: hostnames your app links customers to (skips the external-redirect warning).allowed_sources: up to 20 HTTPS origins your app's code loads from or sends requests to on storefront, checkout, and admin pages, which Shopify uses to spot suspicious activity.
A minimal config looks like this:
[network_access]
allowed_navigation_hosts = ["app.example.com"]
allowed_sources = ["https://api.app.example.com"]
After adding your hosts and servers to the [network_access] section, run shopify app deploy and release the new version to apply the changes.
One caveat: the 20-host limit is pretty tight if your app loads from a CDN, a tracking endpoint, and multiple first-party services. Plan your origins carefully. The Shopify CLI also recently migrated theme app extensions away from a per-extension [extensions.capabilities.network_access] block: declare network origins with [network_access] allowed_sources in shopify.app.toml instead.
ASN-based rules for serverless hosts
Apps without static IP addresses, such as apps on serverless platforms, can now add their hosting provider's autonomous system numbers (ASNs) to the app's IP allowlist in the Dev Dashboard.
An ASN identifies an autonomous system: a network that one organization runs, such as a hosting provider or an ISP. For each request, Shopify looks up the ASN and country of the source IP address in MaxMind's GeoLite data.
In practice:
- Find your provider's ASN. For Vercel it is AS54113 (Fastly, their edge network). For Cloudflare Workers it is AS13335. For AWS Lambda in
us-east-1, the relevant ASN is AS16509. - The IP allowlist section of your app's Settings page lets you allow either IP addresses or Networks (ASN). For networks, enter up to 10 ASNs and limit them to up to 10 countries.
- Test them against recent traffic, then turn on enforcement. Requests from outside your allowed networks fail with a 403 status code.
The country-scoping step is important. If your app only runs in us-east-1, there is no reason to allow ASN traffic from every region the cloud provider operates in. Allowlist only IP addresses when you can, and if you allowlist ASNs, then list only the countries your app runs in.
Static vs. dynamic egress: which approach to use
| Hosting type | Recommended approach | Trade-off |
|---|---|---|
| VPS / dedicated server | Static IP or CIDR block | Narrowest blast radius, simplest to audit |
| Container on a fixed egress IP (e.g. Railway, Render with static IP add-on) | Static IP or CIDR | Same as above; check your provider's NAT gateway IP |
| Serverless (Lambda, Workers, Vercel Functions) | ASN + country restriction | Broader than a single IP; covers the full cloud provider range |
| Kubernetes on managed cloud (EKS, GKE) with NAT gateway | Static IP of the NAT gateway | Use the gateway's public IP, not the pod range |
| Multi-region serverless with unpredictable egress | ASN per region, one country per ASN entry | Up to 10 ASN + country pairs; may hit the 10-entry cap on large deployments |
One real-world complication: background workers, cron jobs, and queue consumers often run on a different host or container than the main web process. Important implementation considerations include identifying outbound public IP addresses, handling multiple production servers, background workers, cron jobs, and other services that communicate with Shopify APIs. Enumerate every process that calls the Admin API before you fill in the allowlist. A 403 from enforcement looks identical to an OAuth error at the HTTP level, so missing one worker will produce confusing logs.
Shopify documents HTTP 403 for Admin API calls from unapproved networks; treat new 403s as a network-policy investigation, not automatically an OAuth or access-scope problem.
Testing on a dev store before you ship
Shopify added a new feature preview that lets developers test their app's network access configuration on a dev store. It confirms whether the right networks are listed and finds hosts or servers that were missed.
The feature preview identifier is network_access_testing. The Network access testing preview helps you test your app's network_access configuration on the online store. Refer to the "Declare your app's network access" docs for details.
What actually happens in the preview:
- On a dev store with the preview, you see a
Content-Security-Policy-Report-Onlyheader, and undeclared hosts just show up as console warnings. - The preview only warns, it does not block anything.
- For navigation links, the feature preview shows the exit warning for links to hosts not in the declared network access list, and logs a console warning when a storefront page loads from or contacts an undeclared server.
The practical workflow:
- Add a
[network_access]block toshopify.app.tomlwith your best guess at all origins. - Create a new dev store and enable the
network_access_testingfeature preview. - Install the app on the dev store and walk through every surface: storefront, checkout, app home, app proxy pages.
- Watch the browser console. Any
CSP-Report-Onlywarning is an undeclared origin you missed. - Add missing entries to
allowed_sources, re-deploy withshopify app deploy, and repeat. - Separately, in the Dev Dashboard, use the test against recent traffic option before turning on IP allowlist enforcement. You can head over to the GraphQL API dashboard, search for each blocked IP, and look at the requests.
One known gap: the dev store tells you things load on that one store, but every merchant's setup is a bit different, so it does not really prove nothing will get blocked on other stores. The dev store test is a necessary but not sufficient check. Run the "test against recent traffic" feature in the Dev Dashboard against your production app's real request log before you flip the enforcement toggle.
Merchant visibility and what it means for your App Store listing
Merchants can now see your app's security setup in Settings > Apps: expiring tokens and IP allowlist. This is live today, not a future change. Any merchant browsing their installed apps can already see which apps have the allowlist enabled. On November 20, affected apps will be delisted from the Shopify App Store, blocked from new installations, and flagged under merchants' Settings > Apps, while existing installations continue operating.
That last clause is important: existing installs are not broken on November 20. The full cut-off for existing installs is April 1, 2027. You have runway, but the merchant-visible flag and App Store delisting are real commercial risks well before that date.
The relationship to expiring offline access tokens
This security push is part of the same October 2026 wave that also accelerated offline token expiry. The two requirements are independent: Shopify's enforcement schedule also includes expiring offline access tokens, but an IP allowlist does not refresh a token and token rotation does not fix an unapproved network. Network origin is now an independent requirement. See my earlier post on the offline token migration steps if you need to handle both at once.
Checklist before you enable enforcement
- Map every process (web server, background worker, cron, queue consumer, bulk-op runner) that calls the Admin API and record its egress IP or ASN.
- Choose the right allowlist type: static IP/CIDR for fixed egress, ASN plus country for serverless.
- Add a
[network_access]block toshopify.app.toml, deploy it, and smoke-test on a dev store with thenetwork_access_testingpreview. - In the Dev Dashboard, run "test against recent traffic" and clear all unexpected blocks.
- Enable enforcement. Watch your app's error logs for 403s in the first 30 minutes.
- Treat any new 403 as a network-policy miss first, not an OAuth problem.
Frequently asked questions
Do custom apps (installed via URL, not the App Store) need an IP allowlist?
Custom apps are exempt from the mandatory requirement, but Shopify strongly recommends adding an IP allowlist for them anyway. A leaked custom app token without an allowlist is just as exploitable as a public app token.
Can I mix static IPs and ASN rules in the same allowlist?
No. Shopify's allowlist currently accepts either IP addresses or Networks (ASN), not both at the same time. Choose the mode that fits your hosting and configure all your egress sources within that mode.
What HTTP status code does Shopify return when a request is blocked by the IP allowlist?
Shopify returns a 403 status code for any Admin API request that originates from an IP address or network not on the allowlist. This looks the same as an OAuth or scope error at the HTTP level, so check your allowlist configuration first whenever you see unexpected 403s after enabling enforcement.