MTG Proxy Decklist Formatting for Moxfield and Archidekt: Clean Exports That Actually Import

You’d think copying a decklist would be the easy part.

But if you’ve ever pasted a Commander list into a card-order form and somehow ended up with 97 cards, three mystery duplicates, and a sideboard that got swallowed by the void, you already know the truth. Decklists only look simple. Under the hood, they’re picky little goblins. A list that reads fine to a human can still confuse an importer if it’s packed with headers, custom tags, category labels, nicknames, or extra formatting.

And that’s where people lose time. Not in deckbuilding. Not in choosing art. In cleanup.

If you use Moxfield or Archidekt, the good news is that both platforms already give you text-based ways to work with your list. Moxfield’s help docs point people to plain-text import from a .txt file and to Bulk Edit for working with raw deck text. Archidekt’s live editor still shows both Text Import and Export deck, and its own forum guidance explains how special categories like sideboard or maybeboard can be tagged in import text. That means the real job is not finding some secret export trick. It’s learning how to make your list boring on purpose.

That sounds less exciting than a full-art foil-looking mana base, sure. But boring decklists are good decklists. They import cleanly. They proof cleanly. And most important, they don’t create the kind of tiny errors that turn into annoying order mistakes later.

So let’s make this easy. Here’s the workflow I’d use if I wanted a Moxfield or Archidekt list to import the first time without drama.

Why decklist formatting breaks even when the deck looks normal

A deckbuilder is built to show you information. An importer is built to parse information.

Those are not the same thing.

Inside a deck site, categories, tags, sections, maybeboard piles, custom printings, and visual groupings all make perfect sense. You can see what belongs where. But when you copy or export that deck somewhere else, the importer usually wants one thing above all: plain text that follows a predictable pattern.

That’s why decklists often break in very normal-looking ways. Maybe your commander is in a separate visual section and the import tool ignores it. Maybe your maybeboard lines came along for the ride. Maybe your list includes headings like “Ramp,” “Draw,” and “Wincons,” and the importer reads those as garbage. Maybe you exported a list with extra symbols, card numbers, or category labels that your print tool doesn’t understand.

None of those mistakes are dramatic. That’s what makes them so common.

The importer doesn’t need your deck to look nice. It needs your deck to be regular. Think quantity first, card name second, everything else only if the destination actually needs it. Once you start thinking that way, most import problems disappear fast.

The safest decklist format is also the ugliest

This is the part people try to outsmart. Don’t.

The safest import format is usually just this:

1 Sol Ring
1 Arcane Signet
1 Swords to Plowshares
1 Command Tower

That’s it. Quantity. Card name. One card per line.

No emojis. No cute section titles. No “maybe cut later” notes. No custom shorthand that only makes sense to you three weeks after midnight deckbuilding. A human can read messy text and fill in the blanks. A parser usually won’t.

Here’s the cleanup rule I like to use before any proxy order:

Keep	Strip out	Move to a separate notes file
Quantity + exact card name	Strategy headers	Maybeboard ideas
One card per line	Personal notes	Tokens to review later
Front-face names for MDFCs	Nicknames and deck tags	Cards you still might swap
Only the cards you actually want printed	Price notes, set callouts, collector details you don’t need	Art/theme ideas

If you have the option to export multiple formats, pick the plainest text version you can get. Your goal is not to preserve every bit of site data. Your goal is to preserve the card names and counts cleanly.

That sounds obvious, but it’s where most people go wrong. They try to carry too much structure from the deckbuilder into the print workflow. And then they wonder why their importer feels cursed.

How I’d clean a Moxfield decklist before ordering

Moxfield is great for brewing, tuning, and presenting a deck. It also gives you two clues that matter here: its help docs say you can create/import from a pasted list or a .txt file, and they also point users to Bulk Edit as a way to work with the raw decklist text. That’s the important part. Bulk Edit is where you stop looking at your deck like a polished page and start looking at it like data.

If I’m pulling a proxy-ready list from Moxfield, I’d do this:

First, get the deck into the plainest text view you can. Don’t worry about aesthetics at this stage. You are not preserving your beautiful organization. You are reducing the chance of a bad parse.

Second, scan for non-card lines. That includes your own headers, comments, reminder text, and any category labels you don’t actually want carried over. A lot of Commander players separate “Ramp,” “Removal,” “Lands,” and “Finishers” because it helps with tuning. That’s useful inside Moxfield. It’s usually not useful inside an importer.

Third, make sure each real card is on its own line with the quantity in front. If anything looks inconsistent, fix it now. This is also the best time to catch copy-paste weirdness like doubled spaces, weird apostrophes, or card names that got mangled by some other export.

Fourth, isolate non-main-deck material. If you only want the main deck plus commander printed, don’t let extra boards drift into the final text blob by accident. Keep one clean file that represents the actual print job.

What I like about Moxfield for this step is that it naturally pushes you toward a raw-text check. That’s good. Every decklist should pass a plain-text sanity test before you order anything.

If your list looks boring in plain text, you’re winning.

How I’d clean an Archidekt decklist before ordering

Archidekt makes this even more obvious because the current editor still exposes both Text Import and Export deck right in the live interface. In other words, Archidekt already expects deck text to be part of the workflow, not some weird edge case.

Where Archidekt gets a little more specific is categories.

Its forum guidance has long shown that if you want a card to land in a special category during text import, you can tag that category after the card name with backticks. The classic examples are:

1 Mountain `Sideboard`
1 Sol Ring `Maybeboard`

And if you need split placement, like one copy in the main and one in the sideboard, Archidekt’s own example is basically to put those on separate lines rather than expecting one combined count to sort itself out.

That matters because it shows you how to think about the tool. Archidekt can handle structure, but only if you express it in a way the importer understands. Visual categories are not magic. They still need syntax.

For proxy ordering, my advice is simple: only keep category syntax if your destination needs it.

If you are exporting from Archidekt and sending the list into a separate card-order system, strip it down unless you know that system understands Archidekt-style category tags. Otherwise, you can end up with lines that made sense in Archidekt but become junk everywhere else.

So the Archidekt version of the workflow is:

Get the text.
Remove what the print importer does not need.
Keep category tags only when they solve a real problem.
And make separate lines do the work whenever you need precision.

That’s not flashy, but it’s reliable.

Commander-specific cleanup that saves a lot of pain

Commander lists are where formatting gets messy fast, because Commander players rarely have just one clean pile.

You’ve got the main 99. The commander. Maybe a partner pair. Maybe a companion. Maybe a maybeboard with thirty cards you’re “still considering,” which usually means “emotionally attached to.” Maybe token notes. Maybe double-faced cards. Maybe a sideboard-ish package you use only in certain pods. It adds up.

So here’s the practical version.

Your print file should reflect the cards you actually want produced, not the full history of how you built the deck.

That means a few things.

Keep your actual deck separate from your maybeboard. This is the biggest unforced error. People export the whole page, forget that the maybeboard came with it, and only notice after a proof looks too long.

Treat tokens as a separate extras pass, not part of the main deck import, unless your workflow specifically asks for them in a separate section. Same with helper cards.

And for modal double-faced cards, use the front-face card name consistently. That lines up with how Magic rules handle those cards in most zones and avoids the mess you get when somebody types the back face or some nickname instead. If the front face is what the importer expects, give it the front face.

This is also the moment to normalize basics, split cards, punctuation, and apostrophes. Tiny name errors are more annoying than most people expect. The importer may fail hard, or worse, it may fail soft and quietly swap in the wrong thing.

A clean Commander list is not just a decklist. It’s a proofreading tool.

The mistakes that keep showing up

After you’ve done this a few times, the same problems repeat.

The first is keeping too much site-specific structure. If your export still looks like a deckbuilder page instead of a plain-text list, it’s probably not ready.

The second is forgetting that “what I see” and “what the importer reads” are different. A beautiful grouped deck can still export like a mess.

The third is mixing real deck cards with support pieces. Main deck cards, tokens, helper cards, sideboard plans, and maybeboard cards all blur together if you do not separate them on purpose.

The fourth is trusting one pass. Don’t. Read the final list top to bottom in plain text once before ordering. It takes a minute. It can save an hour.

And the fifth is trying to be clever with formatting. Clever formatting is great for a blog post. It is terrible for a parser.

A paste-safe MTG proxy decklist template

If you want a low-drama template, use something like this:

1 Atraxa, Praetors' Voice
1 Sol Ring
1 Arcane Signet
1 Fellwar Stone
1 Swords to Plowshares
1 Cyclonic Rift
1 Doubling Season
1 Command Tower
1 Breeding Pool
1 Godless Shrine
1 Temple Garden
1 Watery Grave

If you are staying inside Archidekt and need special placement, use separate lines with category tags only where needed:

1 Scapeshift
1 Scapeshift `Sideboard`
1 Sol Ring `Maybeboard`

And if you’re ordering proxies from that deck, I’d still make one final “print only” file that removes anything not being printed right now.

That last file is the one that matters.

Final thoughts

The best proxy decklist formatting advice is not complicated. It just isn’t glamorous.

Use plain text.
Use one card per line.
Use exact card names.
Keep only the cards you actually want printed.
Treat categories, maybeboard piles, tokens, and helper pieces as separate decisions instead of one giant export blob.

Moxfield and Archidekt both support text-based workflows. That’s the good news. The rest is on you. Don’t ask the importer to guess what you meant. Give it a list so plain it feels almost insulting.

That’s the version that works.