Shopify Doesn't Save Your Metafield History

Does Shopify keep metafield history?

No. Shopify does not maintain any history of metafield changes.

When you update a metafield value from "gold" to "silver", the old value is overwritten immediately. The Shopify admin shows the current value only. There is no changelog, no revision history, no diff view. The GraphQL API returns the current value and nothing else.

The admin activity log under Settings tracks staff actions like theme changes, app installs, and permission updates. Metafield edits are not in there. The resource timeline (on customer, product, and order pages) does not show metafield changes either.

Webhooks are no better for historical data. The products/update or customers/update webhook fires when a resource changes, but the payload only contains the current state. It does not include what the metafield value was before the change, or even which metafield was modified. You just get the full resource object as it exists right now.

So the answer is straightforward. Shopify has no built-in metafield history. If the value changed an hour ago, a week ago, or a year ago, the old value is gone.

When metafield history saves you

Loyalty tier disputes. A customer contacts support claiming they were "gold" tier last week and should still qualify for free shipping. The metafield currently says "silver". Without history, your support team has no way to verify the claim. They either eat the cost or risk losing the customer.

Debugging Flow logic. You built a Shopify Flow that updates a metafield based on order count. Something is wrong. Customers who should be "platinum" are showing as "standard". Did the Flow run? Did it set the wrong value? Did something else overwrite it afterward? Without a change log, you are debugging blind.

Auditing app behavior. You installed a new app that syncs data from your CRM into customer metafields. A week later, you notice some metafield values look wrong. Did the app change them? When? What were the original values? If the app does not keep its own logs (most do not), you have no way to know.

Custom field rollbacks. Someone on your team accidentally bulk-updated a product metafield that controls your storefront display. Maybe they set the wrong value on 500 products. Maybe a script ran against the wrong environment. Without a record of the previous values, rolling back means manually figuring out what each value should be.

Compliance and record-keeping. If you store customer-related data in metafields (preferences, consent flags, account details), you may need to demonstrate when a value was set and what it was before. Metafields without history are a liability in any audit scenario.

What changes metafields

The list of things that can modify a metafield is longer than most people expect.

Shopify Flow. Flow actions can set metafield values on customers, products, and orders. If you have multiple flows touching the same metafield, they can overwrite each other. The Flow run log shows that an action executed, but does not record the previous metafield value.

Custom apps and private apps. Any app with the appropriate API scopes (write_products, write_customers, etc.) can create, update, or delete metafields through the Admin API. A single API call can change multiple metafields at once.

Checkout extensions and Shopify Functions. These run during the checkout process and can read and write metafields. A Function that modifies a cart or order metafield does so during a live transaction, making changes particularly hard to trace after the fact.

Manual edits in the admin. Staff members can edit metafield values directly on any resource page in the Shopify admin. The admin provides no confirmation dialog for metafield changes and no indication of who last modified a value.

CRM and ERP syncs. Middleware tools like Zapier, Make, or custom integrations that push data from external systems into Shopify metafields. These syncs often run on a schedule and overwrite values without checking what was there before.

CSV imports. Shopify's bulk product editor and matrixify-style import tools can set metafield values from spreadsheet columns. A single import can touch thousands of metafields in one operation.

Every one of these sources modifies metafields silently. None of them create a log entry in Shopify.

Why building your own is painful

The obvious first thought: subscribe to webhooks, store the old and new values, build a UI. Sounds like a weekend project. It is not.

The diff problem. Shopify webhooks do not tell you which metafield changed. When a products/update webhook fires, you receive the entire product object. To detect a metafield change, you need to fetch the product's metafields via the API (webhooks do not include metafields in the payload by default), compare every metafield value against your stored snapshot, and identify what is different. For a store with thousands of products and dozens of metafields each, this is expensive.

Type handling. Metafields have types: single_line_text_field, number_integer, number_decimal, json, boolean, date, url, and more. A useful diff needs to understand these types. Comparing two JSON values is not the same as comparing two strings. Showing a meaningful "old vs new" display for a JSON metafield requires parsing and formatting.

Volume and rate limits. A busy store generates thousands of webhook events per day. Each event potentially requires an API call to fetch current metafield values for comparison. Shopify's API rate limits (40 requests per second at the standard plan) become a real constraint. You need queuing, batching, and retry logic.

Storage and retention. Every metafield change needs to be stored with the old value, new value, timestamp, resource type, and resource ID. Over months, this adds up. You need a database schema, retention policies, and search indexing to make the data useful.

The UI. Storing the data is only half the job. You also need a way to browse it. A per-resource timeline view, search by namespace and key, filtering by date range, maybe an export function. Building this as a Shopify admin embedded app with proper authentication and app bridge integration is its own project.

What starts as "just capture webhook diffs" turns into a full application with an API layer, database, background processing, and a frontend. That is months of work for a team that probably has other priorities.

What metafield history should look like

Whether you build it yourself or choose an existing tool, here is the minimum bar for useful metafield history.

Namespace and key identification. Every change record should clearly show which metafield was modified. The namespace and key (e.g., custom.loyalty_tier) should be front and center, not buried in a generic "metafield updated" message. You have dozens of metafields per resource. You need to know exactly which one changed.

Old and new values. The core of any change log. Show the previous value and the current value, side by side. For simple types like strings and numbers, this is straightforward. For JSON metafields, a formatted diff is far more useful than showing two raw blobs.

Precise timestamps. Down to the second. When you are trying to figure out whether a Flow changed a metafield before or after an API call from your CRM, the difference might be 30 seconds. Date-only granularity is useless for debugging.

Per-resource view. You should be able to open a customer, product, or order and see every metafield change for that specific resource in chronological order. A global activity feed has its uses, but the per-resource timeline is what your team will actually use day to day.

Embedded in the admin. If the history lives in a separate app or dashboard that requires a different login, your team will not check it. The best implementation is an app block that shows up directly on the resource page in the Shopify admin. Right next to the metafield values themselves.

Metafields hold the custom data that makes your store yours. Shopify gives you full control over setting and reading these values but zero visibility into how they change over time. If your business logic depends on metafield values being correct, you need a record of when and how they change. Waiting until something goes wrong to realize you have no history is an expensive lesson.