Shopify's metafield size limit dropped 93% in API 2026-04 — from 2MB down to 128KB for JSON and 64KB for everything else. If your store uses metafields for custom product data, B2B pricing, or app configuration, this migration deadline matters: oversized fields become frozen the moment any app tries to update them on the new API version.
The change landed on February 19, 2026. Shopify originally proposed a 16KB cap, then revised it after developer backlash. But even at 128KB, stores running product configurators, page builders, or complex pricing logic in metafields are at risk of silent breakage.
What's the New Shopify Metafield Limit in API 2026-04?
Before this update, metafields could hold up to 2MB of data per field. That was generous enough that developers used them for everything — product configurator settings, complex pricing rules, page builder content, even base64-encoded files.
The new limits landing with API version 2026-04 are:
- JSON metafields: 128KB max (down from 2MB)
- All other types (single-line text, multi-line text, etc.): 64KB max
Existing oversized metafields don't vanish. They're still readable. But the moment an app or integration tries to update an oversized field using API 2026-04 or later, the write fails. The field becomes effectively frozen — you can read it, but you can't change it until you shrink it below the new cap.
Who's Actually Affected (And Who Isn't)
Most stores won't notice. If you're using metafields for basic product details — size charts, care instructions, custom text — you're almost certainly under 64KB per field. A 64KB text metafield holds roughly 32,000 words. You're fine.
The stores that get hit are running more complex setups:
- Product configurators storing option logic and conditional rules in a single JSON metafield
- B2B pricing apps that pack tiered pricing tables for hundreds of customer groups into one field
- Page builders saving entire page layouts as JSON blobs
- Apps storing base64-encoded files — PDFs, images, or large HTML blocks inside metafields
If you've never touched metafields manually and your apps are mainstream Shopify apps, you're likely in the clear. But if you have a developer who's built custom integrations, check with them.
The Grandfathering Exception (Read This Carefully)
Shopify isn't forcing everyone into a hard cutover. Existing apps that already use JSON metafields above the new limits are grandfathered at the current 2MB cap. New apps that need higher limits can apply through a dedicated Shopify intake process.
But "grandfathered" has a catch. It means the app is grandfathered — not your store. If a grandfathered app updates to a new API version internally, or if you switch to a different app that uses the same metafield namespace, the new limits apply. Grandfathering protects the status quo. It doesn't protect you from future changes.
And if you've been writing to metafields through custom scripts or your own API calls (not through an app), there's no grandfathering. Your custom code hits the new limits as soon as it targets API 2026-04.
How Do You Check If Your Shopify Metafields Are Over the Limit?
You don't need a developer for the first check. Go to your Shopify Admin, navigate to Settings → Custom data, and look at your metafield definitions. If you see types like "JSON" or "Multi-line text" attached to products, collections, or customers, those are the ones worth investigating.
For a precise audit, you (or your developer) can run a GraphQL query against the Shopify Admin API that pulls metafield sizes. Here's what to look for:
- Query all metafields by resource type (products, variants, collections, customers)
- Check the byte size of each value — anything over 128KB for JSON or 64KB for other types is at risk
- Flag any metafield namespace/key pairs that multiple apps share — those are the most fragile
Magebit published a detailed audit walkthrough that includes the specific GraphQL queries. If you're not technical, forward this to whoever manages your store's custom data and ask them to run the check.
Three Migration Paths for Oversized Data
If you find metafields over the limit, you have three options. Pick the one that matches your technical comfort level.
1. Split Into Multiple Metafields
The simplest approach. If a JSON metafield holds a 200KB pricing table, split it into two 100KB metafields — one for customer groups A-M, another for N-Z. The limit is per field, not per resource. A product can have hundreds of metafields.
Downside: your app or theme code needs to know about the split. This works for custom code, not for third-party apps you don't control.
2. Move to Metaobjects
Metaobjects are standalone data entries with their own structure, separate from products or collections. Unlike metafields (which are attached to a specific resource), a metaobject can be referenced by multiple products and managed independently.
This is the cleanest migration for complex data. If you're storing designer profiles, ingredient lists, or sizing matrices in metafields today, metaobjects are where that data belongs. Each metaobject has its own fields with their own size limits, so you're distributing the data across a proper structure instead of cramming it into one field.
3. Use the Files API for Large Content
Storing PDFs, images, or large HTML blocks? Those never belonged in metafields. Shopify's Files API lets you upload files and reference them by URL. Your metafield stores the file URL (a few bytes) instead of the file contents (potentially megabytes).
This is the right fix if your oversized metafields contain binary data or formatted content that's really a file pretending to be structured data.
The Bigger Picture: Why Shopify Is Doing This
Shopify cited three reasons for the limit reduction: database infrastructure costs, CDN and caching inefficiency, and abuse of the metafield system. When developers use metafields as a general-purpose database — storing megabytes of configuration, content, and binary data — it slows down storefront rendering for everyone on the platform.
This is part of a broader push. API 2026-04 also deprecated checkout metafields (use cart metafields instead), enforced RBAC on API access, and required expiring access tokens for new public apps. The checkout extensibility migration deadline in August is another piece of the same tightening. Stores with loose custom data practices are the ones feeling it first.
The practical takeaway: audit your metafields this week. If everything's under 128KB, you're set. If not, pick a migration path and move before your next app update targets the new API version. And while you're auditing custom data, check your app dependency chain too — metafields are one breaking point, but apps that share metafield namespaces are another.
The fields won't disappear overnight. But the first time a write fails on a field your store depends on, you'll wish you'd checked sooner. If you're running custom order forms or product configuration that relies on metafields, tools like EasySell store form logic independently of metafield storage — worth considering as part of a migration that reduces your metafield footprint.