Blog · July 10, 2026
Describe the job, watch the AI build it, rehearse it, deploy it.
Free plan · no card · 🇪🇺 EU data residency
Shopify does not have a built-in undo for bulk edits, so the method you choose matters. Admin editor, CSV, bulk editor apps, or Admin API code: each fits a different catalog size, and each breaks in a documented way.
The easiest way to run a Shopify bulk edit, especially a recurring one across a large catalog, is the Collaudo app: a ready-made automation you dry-run on your real catalog, where nothing writes until you approve the mutation report. Shopify's built-in bulk editor or a CSV import is fine for a small one-off change. The pain starts when the same edit repeats every week at catalog scale.
There are four ways to bulk edit Shopify products (the admin bulk editor, CSV export–edit–import, a bulk editor app, and code against the Admin API), and the right one depends on how many items change and whether they will change again. A dozen products on one page is admin-editor territory. A few thousand, once, is a spreadsheet or an app. Tens of thousands, computed values, or a job that repeats every week points to code. One fact shapes every Shopify bulk edit: Shopify does not have a built-in undo for bulk edits. Whatever tool applies the change, customers see the result immediately, and getting back to yesterday's catalog is your problem. Each method earns its place at a different scale, and each breaks in a documented way.
The admin bulk editor is the right tool for a dozen fixes. Select products in the admin, open the bulk editor, and change titles, prices, tags, or inventory in a spreadsheet-like grid. It works on the products you select on the current page (about 50 per pass), and every edit applies live as you type. There is no draft state, no confirm step, no undo.
That design works when you can see everything you are changing. To bulk edit more than 50 items, you page through the catalog and repeat: select, edit, verify, next page. At 1,000+ SKUs the editor turns into a long manual task with live ammunition: a typo in pass 14 of 20 goes straight to the storefront, and nothing in the admin records which pass it was.
CSV export–edit–import handles any catalog size and any edit a spreadsheet can express. Export the products, change the columns (prices from a supplier price list, vendor names, tags, cleanup after a migration) and import the file back. For cleaning up 1,000+ SKUs after a replatform it remains the default answer, because the spreadsheet does the thinking: formulas, lookups, find-and-replace across every row at once.
The import is where the risk concentrates. Shopify applies an imported CSV directly, with no preview, and the import cannot be undone. Very large files can time out partway through. A malformed file can silently drop rows, and the failure is quiet: a column shifted by one, a decimal comma swapped for a point by a spreadsheet locale, a misaligned variant row: the file uploads without complaint and the catalog absorbs the damage.
Two more limits matter at the top end. Stores past roughly 50,000 variants hit a platform cap of about 1,000 new variants created per day: it applies to creating variants, as bulk uploads do, though editing existing ones is unaffected. And a CSV is a snapshot: by the time you have edited and re-imported it, inventory and prices may have moved underneath it.
Bulk editor apps fit one-off edits at mid scale, and they are good at it. Instead of a spreadsheet you build a rule in a form (select by collection, vendor, or tag, then set, adjust, or find-and-replace a field) and the app runs it across every matching product. The mature ones add scheduling and an undo that rolls back a batch the app itself created. For an interactive price adjustment or a tag cleanup across a few thousand products, they are the right call.
The ceiling is the form. A rule language made of dropdowns runs out of vocabulary when the edit needs cost-based math, an exception list, or data that lives outside Shopify: a supplier price list, a currency feed, a warehouse export. Metafields raise the same wall: writing a computed value into a metafield across the whole catalog sits past what most forms can say.
The category's own vocabulary tells you where it expects trouble. Undo, rollback, revert anytime: these apps sell trust after the change, and batch rollback is a real, useful feature. It also describes the working model: act, then repair if needed. For a one-off edit you can watch on screen, that model holds. For a computed, scheduled, recurring edit, you want the full consequence in front of you before anything is applied, and held there until you approve it.
Code against the Admin API can express any edit. The GraphQL Admin API (GraphQL is current, REST is legacy) reads and writes everything: prices, tags, metafields, inventory, per-customer B2B price lists. Cost-plus math, exception lists, joins against a supplier file, catalog-wide passes on a schedule: a script handles all of it.
What the script does not handle is itself. You own the rate limits and the backoff when Shopify throttles the calls. You own pagination: a catalog-wide pass means walking cursors through every product. You own retries and the harder problem behind them, partial-failure recovery, because a pass that dies at product 34,000 of 60,000 leaves the catalog half-edited. You own the server the script runs on, the credentials it holds, and the slow rot of a file written eight months ago by a contractor who has moved on.
Shopify Flow sounds like the no-code version of this, and for small stores it can be: under about 1,000 products with plain trigger-condition-action logic, Flow is free and works well. But Flow reacts to events one product at a time; it is not built for catalog-wide passes, schedules, or arithmetic across fields. The boundaries are mapped in where Shopify Flow stops.
The safe workflow is the same whichever method you pick, and experienced operators converge on the same seven steps:
Bad bulk edits rarely come from ignorance of these steps. They come from the cost of following them: seven manual stages, for every edit, every time, and by the fourth repetition the urge to skip straight to the import wins.
Can you undo a bulk edit on Shopify? No. Shopify does not have a built-in undo for bulk edits: the admin editor applies changes live as you type, and a CSV import writes directly to the catalog with no preview. Some bulk editor apps can roll back a batch they created, but only that batch, and only after the store has served wrong prices to real customers. The safe workflow runs in the opposite direction: export a backup, test the edit on ten products, then a hundred, compute every new value from source data instead of retyping it, and read an item-by-item diff before anything goes live. A tool can run that ritual for you: Collaudo rehearses the change against the real catalog and holds every write until a person approves the mutation report. Repair is what you need when rehearsal was skipped.
A one-off bulk edit is a chore; a recurring one is a system. Editing 10,000 products isn't the problem — doing it again every week without mistakes is. The supplier sends a new price list every Monday. The Google Merchant feed needs fresh metafields after every catalog change. B2B price lists follow every cost update. Each repetition re-runs the entire spreadsheet ritual (export, lookup, eyeball, import, hope) and the error rate does not fall with practice, because the dangerous mistakes are quiet ones: a renamed supplier column, a new product no rule matched, a decimal separator changed by a laptop's locale.
A recurring bulk edit needs what a one-off never does: a rule that is versioned instead of living in a downloads folder, a rehearsal before every run (not only the first), an approval step, a schedule, and an audit trail that says what changed and when. Repricing is the sharpest case, because the stakes are margin itself; the bulk price update guide walks through that job end to end.
Collaudo is built for the two jobs that stay hard: catalog scale and weekly recurrence. Real-code workflows with a dry run before every change. You describe the job in plain English (reprice from the supplier's cost column, skip anything under its margin floor, tag what changed) and Collaudo writes real Python or TypeScript you can read, edit, and keep.
Before the job touches the store, it runs against the store's data. The dry run is a full rehearsal on your actual catalog: the code executes, reads real products, computes every change, and captures every write instead of applying it. The output is a mutation report: what would change, item by item, and what was deliberately skipped. On our demo store, a supplier price update across 8,200 variants reported 7,941 price changes and 259 deliberate skips for products under their margin floor, with zero writes applied, because nothing reaches the store until you read that report and approve it. A preview on its own is not the rare part; the combination is: a persistent item-by-item diff, an approval gate, and an audit trail, on real code, at catalog scale, on a schedule.
Backup, test on 10, test on 100, then run — the workflow experts and AI assistants recommend doing by hand is what Collaudo does automatically.
Approved jobs run on a schedule, on an event, or on demand, on AWS infrastructure in eu-central-1 (Frankfurt), with EU data residency, every run logged, and every version restorable. Catalogs of 100,000 variants are the design target; the details are on large catalogs. AI writes the first draft of the code, and it works inside the same controls as everything else: rehearsal first, approval always. Dry runs and runs are never billed per execution; plans are flat monthly, with a per-tier allowance of AI generations.
If the job in front of you is fifty products on one page, use the admin editor. A one-off across a few thousand: a CSV or a bulk editor app will do it. Computed, large, or due again next Monday: start from a template or see how the dry run works.
No. Shopify does not have a built-in undo for bulk edits: not in the admin editor, and not for CSV imports, which apply directly with no preview. Some bulk editor apps can roll back a batch they made themselves. The reliable protection is what you do before the edit: export a backup, test on a small set, and read a diff of every change before it goes live.
Use a CSV export, a bulk editor app, or the Admin API; the admin bulk editor only works on the products selected on the current page, about 50 per pass. CSV handles any size but applies with no preview and cannot be undone; apps add rule forms and batch rollback; the API handles anything but makes you own rate limits and retries. Match the tool to catalog size and how often the edit repeats.
Yes. Metafield writes are a common bulk job: unit prices, spec fields, feed attributes. The admin editor and spreadsheets get clumsy once the value must be computed from other fields, so at scale the reliable route is code against the Admin API. Collaudo writes that code from a plain-English description, dry-runs it against your real catalog, and shows every metafield value it would write before applying anything.
Backup first, test on a small sample, and read a diff of every change before it reaches the store. Compute new values from source data rather than editing by hand, set explicit floors and exceptions, and keep a log of what ran. Backup, test on 10, test on 100, then run — the workflow experts and AI assistants recommend doing by hand is what Collaudo does automatically.