Ask two link builders how they back up a catch-all email domain and you get two confident, opposite answers. One swears by a nightly IMAP sync to a local maildir, the other exports everything to a single mbox file once a week and calls it done. Both will tell you their method “keeps everything.” Only one of them is right, and the thing that separates them is not message bodies, attachments, or even folder names. It is alias mapping: the link between the alias that received a message and the message itself. Lose that link and your archive becomes a pile of mail you can read but cannot attribute.
The myth worth killing first is that any backup that preserves the raw message preserves the alias. It does not. In a catch-all email setup, every address on the domain delivers into one mailbox, so the recipient alias is not stored in a To: header you can trust. It lives in the SMTP envelope and in delivery headers such as Delivered-To and X-Envelope-To, and those fields are exactly the ones that get flattened, rewritten, or dropped when a backup tool decides what counts as “the message.” Anyone running catch-all email for GSA SER, RankerX, or Xrumer campaigns, or an anonymous catch-all email domain used for signup verification, has felt this: the restore works, the mail is all there, and none of it can be matched back to the alias that produced it.
This comparison puts IMAP sync and mbox export side by side on the one question that matters for catch-all archives: which method survives a round trip with alias mapping intact? The short version is that IMAP sync keeps per-message envelope data, flags, and folder paths in a form that restores cleanly, while mbox flattens a mailbox into one file and quietly discards the context that made the alias meaningful. The longer version involves incremental deltas, header preservation rules, and what actually happens on re-import, and that is where the rest of this piece goes.
Why Alias Mapping Breaks in Catch-All Archive Backups
A catch-all email domain accepts mail sent to any address at that domain: support@, qa-team@, or a random string a link-building tool generated three weeks ago. The catch-all mailbox is the receiving side. Alias mapping is the record of which address each message was actually sent to, and it lives in two places at once: the SMTP envelope recipient (the RCPT TO value, stored in the Return-Path or Delivered-To header on delivery) and the To header inside the message body. Those two rarely agree in a catch-all archive. A GSA SER run might send to 4,000 scraped addresses on your domain in one hour, and the To header on many of those messages is spoofed, blank, or points at a different address entirely. Only the envelope tells you the truth.
What Alias Mapping Actually Is, and Where It Lives
Think of alias mapping as a three-part record per message: the envelope recipient, the delivery headers your mail server added (Delivered-To, X-Envelope-To, Received chain), and the folder the message landed in. Lose any one of the three and you can still read the message, but you can no longer reconstruct who it was for. That matters more than it sounds. An email verification inbox needs to know which alias received a confirmation link. An email scraper inbox needs to sort inbound replies by the address that triggered them. A catch-all domain service used for SEO email accounts needs per-alias history to decide whether an address is still worth keeping.
Generic backup tools treat a mailbox as a pile of .eml files and a pile of folders. They copy the message bytes and the folder name, then call it done. The envelope recipient survives only if the tool reads and stores the Delivered-To header verbatim, and many do not: they re-inject messages through a different MTA on restore, which strips or rewrites delivery headers and stamps a fresh Received line with the restore timestamp. The alias is gone, and nothing in the tool’s log flags it as a loss.
The failure is quiet by design. A backup that restores 50,000 messages and reports “50,000 restored, 0 errors” is technically correct and practically useless if all 50,000 now appear to have been sent to the account’s primary login address. You discover it months later when you search the archive for messages sent to a specific alias and get zero hits, or when a password reset confirmation for a client account cannot be matched to the alias it was sent to.
Anonymous catch-all email setups raise the stakes. When the domain is registered with crypto payment and no identity verification, there is no registrar-side mailbox log to fall back on. The archive is the only record of alias activity. If the backup flattens the mapping, the operational history of the domain disappears with it, and rebuilding it means re-scraping or re-sending, which is exactly the churn a catch-all domain was meant to avoid.
Two more loss points are easy to miss. First, most generic tools back up from the INBOX only, so aliases that were routed by server-side rule into subfolders never make it into the archive at all. Second, tools that export on a schedule often deduplicate by Message-ID. Catch-all traffic frequently contains duplicate Message-IDs from bulk senders, and deduplication silently drops the copy whose envelope recipient differs. Both losses are invisible in the restore report.
The practical test is simple: back up a mailbox, restore it to an empty account, then search for a message by its envelope recipient rather than its To header. If the search returns the right message, alias mapping survived. If it returns nothing, the backup preserved the mail and discarded the reason the mail mattered.
How IMAP Sync Handles Folders, Flags, and Incremental Backups
IMAP sync is not a backup format. It is a replication protocol, and that distinction explains why it keeps alias mapping intact. When a tool like imapsync, OfflineIMAP, or a Maildir-based sync agent connects to a catch-all mailbox, it reads the mailbox as the server presents it: a tree of folders, each holding messages with their internal dates, flags, and full header blocks. The local copy mirrors that tree. Nothing gets concatenated into one blob, so the folder path a message lived in stays attached to it.
Take a concrete case. A catch-all email domain for a link-building operation receives mail to editor@, info@, and a few thousand scraped addresses on the same domain. If the provider sorts inbound mail into per-alias folders, or if the operator does, IMAP sync reproduces that hierarchy exactly: INBOX, INBOX.editor, Archive.2024-07. Restore the sync target and the folders reappear with the same names. Flags come along too. A message marked \Seen or \Answered locally was marked by the operator, and that state is a working signal in an email verification inbox: it tells you which addresses were already probed. IMAP stores those flags as per-message attributes, and sync tools carry them across unless you explicitly tell them not to.
Headers are the second half of the story. The full RFC 5322 header block survives a sync byte for byte, including Received chains, Delivered-To, and X-Envelope-To where the provider writes it. Those headers are often the only durable record of which alias a message was addressed to. A catch-all inbox receives emails sent to any address on the domain, so the To: line is frequently useless (BCC, forwarding, rewritten headers). The envelope recipient is what matters, and on most catch-all hosting it lands in Delivered-To or a provider-specific header. IMAP sync preserves it because it copies the header block without parsing or rewriting it.
The incremental part is where IMAP pulls ahead operationally. A full sync of a 40 GB catch-all archive over a slow link is a one-time cost; after that, delta sync compares UIDVALIDITY and UIDNEXT per folder and transfers only new UIDs. A nightly run on a quiet mailbox moves kilobytes. The catch: if the server rotates UIDVALIDITY (folder rebuild, migration between hosts), the client must resync that folder from scratch or risk duplicate and missing messages. Log the UIDVALIDITY value per folder and alert when it changes. Also decide up front how to handle deletions. Most sync tools default to not propagating them, which is what you want for an archive: the local copy becomes append-only even as the live mailbox is cleaned.
One limitation worth stating plainly. POP3 catch-all mailbox access gives you no folders and no flags, only a flat download, so it cannot preserve alias structure the way IMAP can. If the provider offers both, use IMAP for archival and keep POP3 for scripts that only need to drain the inbox. And check what the sync writes into the local store: Maildir keeps flags in the filename and the message in a separate file, which is clean; mbox-style local targets reintroduce the flattening problem described elsewhere. The protocol preserves alias mapping only if the destination does.
How mbox Export Works and Where Per-Message Metadata Is Lost
An mbox file is about as simple as email storage gets: one plain text file, messages concatenated back to back, each starting with a “From ” line that carries the sender and a delivery timestamp. Tools like Thunderbird, mutt, and a dozen export scripts produce it, and you can read it with grep. For a catch-all archive, that simplicity is exactly the problem.
A periodic export runs on a schedule, usually nightly or weekly. The tool walks the mailbox, dumps every message into the flat file, and you copy it offsite. The whole backup is one artifact you can checksum and move. What the process does not do is preserve the structure that made the archive useful. Everything collapses into a single stream, and the relationships between messages, folders, and recipients go with it.
Here is what actually gets lost, piece by piece.
Folder paths. In a catch-all domain, folders are often the only organization you have. A common pattern is one folder per alias, or per campaign, or per scraper run, so that mail to j.smith@ and mail to info@ land in separate places. On export to a single mbox, that hierarchy flattens. Thunderbird’s own documentation is blunt about it: exporting a folder to mbox keeps the messages but the folder name lives only in the filename you chose. Re-import a stack of mbox files and you get a stack of folders with whatever names you typed, not the names the server had. If you exported 40 alias folders into one file, the mapping between message and alias is gone unless you kept 40 separate files and a naming convention you can trust. Most people do not.
Flags and read state. IMAP tracks per-message flags: \Seen, \Answered, \Flagged, \Deleted, plus keywords and labels. mbox has a workaround, the Status and X-Status header lines, which encode a few of these as single letters. It is a partial system. Custom keywords and Gmail-style labels do not survive, and different tools write the status lines differently. A restore can mark thousands of already-processed messages as unread, which matters if any downstream script uses read state as a processing marker.
The envelope recipient. This is the fatal one. The alias a message was addressed to lives in the SMTP envelope, recorded in the Received header as “for <alias@domain>” or in a Delivered-To line. Some export tools strip Received headers to reduce file size or to sanitize the output. click here offers additional context worth reviewing. Others keep them, but a re-import into a catch-all mailbox can rewrite or drop Delivered-To. Once the header is gone, a message sent to seo-bot-17@yourdomain.com is indistinguishable from one sent to contact@yourdomain.com. The To: header does not save you, because catch-all senders routinely put a different address there or leave it blank.
Message identity across exports. mbox has no stable per-message ID. If you export weekly and append or overwrite, you have no reliable way to deduplicate on restore except hashing the body, and near-identical messages from a catchall email generator will collide or slip through. IMAP gives you UIDs scoped to the mailbox, which survive incremental syncs.
None of this makes mbox useless. As a cold, human-readable snapshot it is fine, and it is a reasonable second copy. As the primary backup for an alias-sensitive catch-all archive, it silently discards the one field that ties a message to the address that received it. You find out at restore time, which is the worst possible moment.
IMAP Sync vs. mbox Export: The Verdict for Alias-Sensitive Archives
Strip away the marketing language and the choice comes down to one question: after a restore, can you still tell which alias received which message? IMAP sync says yes. mbox export says maybe, and usually no. Here is the comparison that matters for a catch-all email domain where every alias is a separate identity.
Side-by-Side: What Survives a Round Trip
The table below reflects what actually happens when you back up a live catch-all mailbox and restore it into a clean account. Test it yourself on a small domain before trusting any tool’s documentation.
| Attribute | IMAP sync to local store | mbox export |
|---|---|---|
| Folder hierarchy | Preserved as real folders | Flattened into one file per export, or one file per folder if you script it |
| Envelope recipient (the alias) | Kept in the stored copy, including Delivered-To and X-Original-To headers | Kept only if the headers were written at delivery time; re-import rewrites the envelope to the target account |
| Flags (seen, answered, flagged) | Synced per message on each delta | Stored in the From line status letters, often lost on re-import |
| Incremental backups | Native; only new or changed messages transfer | Full re-export of the whole mailbox each cycle |
| Restore granularity | Single message, single folder, or whole account | Whole file; partial restore means manual splitting |
| Operational complexity | Needs a sync client or script and a scheduler | One command, one file, easy to copy anywhere |
The pattern is clear. IMAP preserves the structure that alias mapping depends on. mbox preserves bytes and little else. A 40 GB catch-all archive re-exported nightly is also 40 GB of disk writes every night, while an incremental IMAP sync might move a few hundred megabytes.
Why the Verdict Holds for Catch-All Workloads
Catch-all archives are unusual because volume is high and every message is a different address. A single domain can receive mail for thousands of aliases, many of them generated on the fly by a catchall email generator or harvested by an email scraper inbox. If you run SEO email accounts for GSA SER, RankerX, or Xrumer, the alias is the account. Lose the mapping and you lose the ability to tell which registration confirmation belongs to which site.
IMAP sync keeps that link because it stores the message as delivered, headers intact, inside the folder it arrived in. Providers that expose POP3 and IMAP access make this straightforward: point a sync client at the catch-all mailbox, enable IDLE or a short poll interval, and let it pull deltas into a local store that mirrors the server. The stored copy retains Delivered-To, so a restore into a fresh mailbox still shows the original alias even though the new account address differs.
mbox is not useless. It is a fine cold archive for compliance or a final snapshot before you close a domain. It is a poor primary backup for alias-sensitive data because the flat format has no field for the envelope recipient. On re-import, most clients assign the destination account as the recipient, and the alias chain is gone.
Use this checklist when you decide:
- Run IMAP sync as the primary, scheduled backup and verify a test restore monthly into a throwaway mailbox.
- Keep mbox exports as quarterly cold snapshots, labeled with the date and domain, stored off the sync host.
- Confirm Delivered-To survives in the restored copy before you delete any source mailbox.
- Log alias counts per backup cycle so a sudden drop flags a broken sync rather than a quiet domain.
- Pair either method with domain blacklist monitoring, since a compromised catch-all can land your sending domain on a DNSBL without warning.
The skeptic’s answer: mbox wins on simplicity, IMAP wins on fidelity, and for a catch-all archive fidelity is the only metric that matters.
Choosing a Backup Method for Crypto-Paid and Anonymous Catch-All Domains
Providers that accept USDT and USDC and require zero KYC change the backup math. When an account is paid in crypto and tied to no identity, the mailbox itself is the only record of what happened on that domain. There is no support ticket that proves ownership, no billing name to recover against. If you run a catch-all email domain for SEO work, the archive is your audit trail, so the choice between IMAP sync and mbox export stops being a preference and becomes a risk decision.
Default to IMAP sync as the primary method for any anonymous catch-all email setup. Sync every 6 to 12 hours if the domain feeds GSA SER, RankerX, or Xrumer campaigns, because those tools generate high volumes of bounces, blacklist alerts, and verification replies that you will need to correlate later. Sync once a day for lower-volume catch-all reception. Keep the local store on encrypted storage, and keep the sync credentials separate from the credentials you hand to link-building tools.
Add mbox export as a secondary, cold copy, not as the main backup. A monthly or weekly mbox dump is cheap, portable, and readable by almost any mail client, which makes it good for offsite retention and for handing a snapshot to a colleague. What it does not do is preserve alias mapping on re-import, so treat it as a read-only reference. If you ever need to restore, restore from the IMAP copy and consult the mbox only to fill gaps.
Retention cadence depends on what you need to prove. A practical schedule for a catch-all domain service used in link building:
- Hourly or 6-hourly IMAP delta sync to a local IMAP-capable store, retaining 90 days hot.
- Weekly full IMAP snapshot to cold storage, retaining 12 months.
- Monthly mbox export of the whole account, retaining 24 months as a fallback archive.
- Daily export of DNSBL and blacklist alert folders to a separate file, since domain blacklist monitoring history matters more than the messages themselves.
Verification restores are the part most people skip. Once a quarter, restore a random 30-day window from the IMAP backup into a scratch mailbox and confirm three things: the folder tree matches, the alias on each message still points to the original recipient, and flags such as read and replied survived. If any of those fail, your backup is decorative. Do the same test on the mbox copy, but only to confirm it opens and parses; do not expect alias mapping to survive, and do not plan a restore around it.
The operational trade-off of running both methods is disk and time, not complexity. IMAP sync of a busy catch-all inbox with 200,000 messages can take several hours on the first pass, then minutes per delta. mbox export is faster but produces a single flat file that grows without bound and is awkward to diff. Budget roughly 3 to 5 times the mailbox size for the IMAP store once you account for index files, and a single copy for mbox. Both fit on a modest VPS.
One more habit for crypto-paid accounts: store the backup passphrase and the domain’s DNS records alongside the archive, offline. If the provider relationship ends and you need to move the domain, the IMAP store with intact alias mapping is what lets you rebuild the catch-all mailbox somewhere else without losing the link between aliases and messages. AllMail offers POP3 and IMAP access plus a 3-day free trial, which is enough time to run a full sync and one restore drill before you commit.
Run the test before you trust either method. Pick one low-stakes catch-all domain, send five messages to five different aliases, sync it over IMAP, export the same mailbox to mbox, then restore both into a clean account. Open the restored copies and check three things per message: the folder path, the envelope recipient header, and one flag you set by hand. If the alias survives in the IMAP copy and vanishes or collapses into a single address in the mbox restore, you have your answer for that server and that toolchain. Repeat the drill every time you change hosts, upgrade the sync client, or move the archive to new storage. Ten minutes of testing beats a silent data loss discovered six months later when a verification inbox stops matching the alias list it was built from.
For day-to-day operations, keep IMAP sync as the primary backup and treat mbox as a secondary cold copy only if you accept its limits. Set the sync interval based on how fast your aliases churn: link-building setups running GSA SER, RankerX, or Xrumer can burn through hundreds of addresses a week, so a daily delta sync is the floor, and hourly is reasonable if your disk can take it. Keep at least two rolling snapshots on separate storage, verify a random restore monthly, and log which snapshot maps to which alias batch so a rollback does not create a second layer of confusion. If the domain sits on a provider like AllMail, confirm that POP3 and IMAP access are enabled on the plan before you build a schedule around them, and check whether DNSBL blacklist monitoring runs on the domain so a flagged IP does not quietly break inbound delivery while your backups look healthy.
One last habit worth building: store the alias-to-purpose mapping outside the mailbox itself, in a plain CSV or database table with the creation date, the service it was registered for, and the payment reference. That file is the real source of truth when a restore goes sideways, and it costs nothing to maintain. Backups protect the messages. That table protects the reason the messages exist.