One evening after my Huawei shift I opened a spreadsheet with 1,031 rows and a proud column header that said Verified Email. It was a cold email list I had bought from a data vendor, and I had been treating it like money in the bank. Then I checked it myself. Only 386 addresses were actually safe to send. 620 needed a human to look again. And 25 were provably dead, dead in a way anyone can confirm for free, from any browser, in about ten seconds.
One dead row still bothers me. A big courier company sat there with a confident looking address, and its domain publishes a NULL MX record, which is a public sign nailed to the front of the domain saying this company refuses all mail. Every email to that address bounces, always. The vendor sold it anyway, which can only mean nobody there ever ran the one free check that would have caught it.
Why bought lists lie, and code cannot
When I dug into those 1,031 rows, the pattern was almost funny. Nearly every address followed one of three tidy shapes: first name at the domain, first initial plus last name, or first dot last. Real collected data is never that clean, because real inboxes are messy and follow no single rule. Something had seen a person's name and a company domain and filled the blank the way a student fills an answer he does not know, quietly and confidently, in the same handwriting as the answers he does know. Then the column said Verified, because Verified was what the label was supposed to say.
Watching that number fall from 1,031 to 386 stung for about ten minutes, and then it felt good, because for the first time I knew exactly what I was holding. It also handed me the one rule the whole method rests on. AI is welcome to suggest which companies to chase and to help write the copy, and I lean on it for both, the same way I described in how I find freelance clients with AI. But only code may produce an email address, because code keeps an address when that address was printed on a page and drops it otherwise, and it never fills a blank to make the list look finished. A language model will.
AI may suggest companies. Only code may produce an email address.
A factory with four stations
So I stopped buying lists and built a small machine that makes its own, free, from public data, with a proof trail behind every address. The shape that made it trustworthy is a factory with four stations, where each one feeds the next and none of them has a step where guessing is even possible.
Station one discovers real businesses from a free public map. The companies come from OpenStreetMap, which millions of volunteers have filled with real places, and for many of those places they also typed in the business website. A free service called the Overpass API lets a script ask the map for, say, every accountant in one city that has a website, with no account and no API key. Keep only the ones that carry a website tag, because the website is where the proof will live.
Station two scrapes only what is printed. It visits each site and keeps an address only when it is literally printed on a page a human could load, and it saves the source URL beside every one. That column is the difference between a list and a claim, because you can click any row and watch the email sitting on the company's own page.
Station three proves every domain against DNS, and station four ranks what survives and keeps one contact per company. The map found the business, the website printed the address, and DNS decides whether that address can even receive mail. Nothing invented ever enters, because no station is allowed to invent.
Prove a domain in ten seconds
Printed does not mean alive. Companies close, domains lapse, and a few tell the whole internet, in a technical way, that they refuse all mail. Send to those and they bounce, and every bounce quietly teaches Gmail and Outlook to treat your future mail as junk. One check catches most of them, and you can run it right now without installing a thing.
When a mail server wants to reach someone at company.com, it first asks the internet where mail for that domain should go. The answer is the MX record, the sign on the door that says mail accepted here, and you can read that sign yourself through DNS over HTTPS.
| DNS answer | What it means | What you do |
|---|---|---|
LIVE MX | Mail records exist, the domain accepts email | Keep the row |
NXDOMAIN | The domain itself is gone, the building no longer exists | Delete with full confidence |
NULL MX | The domain publicly refuses all mail, on purpose | Delete it, reach them by form or LinkedIn |
NULL MX is the sly one, and it is what caught the courier from my audit. The domain exists, the site may even look healthy, but its DNS publishes a single dot where the mail server name should be, which is the official way of saying do not even try.
That free MX check is only the first of three gates. The second gate ranks the survivors so your email lands with one real person who can act on it, and it keeps a single contact per company so you never hit one small firm twice in a day. The third gate knocks on the mail server about the exact mailbox, right before you send, and I run only that week's batch through it because the free tiers are small and that limit is really a discipline in disguise.
6,523 rows and a blank Sent column
Now the part I would rather skip. The machine worked. It produced about 6,000 verified emails across 7 countries, every one printed on a real page, every domain proved by DNS, every row carrying its source URL. And then I froze. There is a file on my computer right now with 6,523 rows in it, and the Sent column is blank on every single one. I kept polishing the factory because building feels like progress while sending feels like exposure, and a perfect list that never leaves your disk is just a heavier way to procrastinate.
So learn from my freeze, not only from my factory. Do not chase 6,000 rows. Prove the 20 or 50 you will genuinely write to this week, and send them, because bounces clean the list and momentum kills the freeze, and neither can happen while the file sits still.
The whole idea fits in one breath. Bought lists lie because something guessed the addresses, so you build your own instead: discover real companies free from OpenStreetMap, scrape only what is printed with its source URL beside it, and let DNS prove every domain before you trust it. You already ran the core check on google.com, so you already know it works. Pick one city you can legally email, prove a handful of addresses, and send them this week.
If you would rather have the pieces already assembled, the exact Claude Code build prompts, the discovery and scrape scripts, and the full verify pipeline live inside Build a Lead Machine That Cannot Lie, the done for you version of everything above, and members get every product I make for free. Either way, the map is already filled in. Go read one MX record tonight.