Article
How to Export Only Valid Emails After Verification (Step by Step)
By Unlimited Verifier Team ·

Summary
To export only valid emails after verification, download the Valid results as a CSV, Excel or JSON file, then confirm that Valid, Risky and Invalid add up to your uploaded row count. Import only the Valid file into your email platform and suppress the Invalid addresses first so they cannot return through your master list.How do you export only valid emails after verification?
To export only valid emails after verification, download the Valid results as CSV, Excel or JSON, check that Valid + Risky + Invalid equals your input row count, and import only that Valid file into your email platform, exporting within 24 hours on Free or 30 days on Pro.
Export the file before retention expires, and treat it as the single source of truth for your next sends. Everything else, including the Invalid and Risky buckets, is handled separately.
Quick answer
- Export the Valid bucket on its own. Keep Invalid addresses in a suppression file and hold Risky addresses out of your main sends.
- Export before retention runs out. Unlimited Verifier keeps results 24 hours on Free and 30 days on Pro, so export the same day you verify.
- Reconcile the counts. Valid + Risky + Invalid should equal the number of rows you uploaded. If it doesn't, don't trust the export yet.
- Suppress before you re-import. Import your suppression file first, or invalid contacts can return through your original master list.
- Match the format to the destination. CSV for most email platform and CRM imports, Excel for review, JSON for scripts and the API.
Why export Valid as a separate file instead of cleaning the master list?
A separate Valid file gives you a clean send list and a record of what you removed. Deleting rows from your master file erases that record and makes it easy to re-import bad addresses by accident.
The two most common mistakes both leave you without proof. Some teams re-upload the original list to their email platform and trust its built-in bounce handling to catch problems. Others delete the Invalid rows in a spreadsheet and save over the original. In both cases you can't show what was removed, when, or why.
A separate Valid file does three things a cleaned master file can't:
- It is the send list. Only contacts in that file go into your next campaign or sync.
- It is reproducible. If someone asks later which addresses passed, you can point to a dated file rather than reconstructing it from memory.
- It keeps the other buckets alive. Invalid goes to suppression, and Risky goes to a held segment you can test later. Neither gets lost in the cleanup.
Bottom line: Give Valid its own file with its own date stamp. It becomes your send list, and nothing else goes into it.
What is the difference between the Valid, Risky and Invalid exports?
Each bucket answers a different question, so each goes to a different destination. Unlimited Verifier sorts every address into Valid, Risky or Invalid. The table below shows where each one belongs.
| Bucket | What it means in practice | Where it goes | Action |
|---|---|---|---|
| Valid | Passed the syntax, domain, MX and SMTP mailbox checks | Your primary send list, or a new segment in your ESP | Keep and send |
| Risky | Addresses that can't be confirmed cleanly, such as catch-all domains, which accept mail for any address | A held segment, tested later in small sends | Hold; don't mix with Valid |
| Invalid | Failed a check, such as bad syntax, a dead domain or a nonexistent mailbox | Your suppression file | Suppress permanently |
The Risky bucket needs the most judgment. A catch-all domain accepts mail for every address, so a Risky result means the mailbox can't be confirmed. It doesn't mean the person is bad. Disposable and role-based addresses such as info@ are flagged as well, and those flags tell you why a contact may need holding. For a method to test this group without damaging your sender reputation, see our guide to unknown emails after verification. You can also check how catch-all domains are handled with catch-all email verification.
Bottom line: Only Valid goes into your send list. Invalid goes to suppression, and Risky waits in its own segment.
Which export format should you choose: CSV, Excel or JSON?
Choose CSV when the file is going into an email platform or CRM, Excel when a person needs to review it, and JSON when a script or API pipeline will process it. Unlimited Verifier exports all three formats, so the right choice depends on where the file goes next.
| Format | Best for | Main pitfall |
|---|---|---|
| CSV | Re-importing into an ESP or CRM. The format is described in RFC 4180 | Some regional Excel settings use semicolons as the delimiter, so opening and re-saving can split columns |
| Excel | Manual review, filtering, and sharing with colleagues who don't work in code | Saving as an older encoding can corrupt accented characters in addresses |
| JSON | Developers and automated pipelines | Most marketing platforms don't import JSON directly, so you'll need to convert it first |
The Excel pitfall deserves more attention than it usually gets. A CSV is plain text, and UTF-8 is the encoding most modern tools expect. If you double-click a UTF-8 CSV in Excel and save it in a legacy encoding, characters outside basic ASCII can change. The corruption is often invisible until an import fails or bounces start appearing. To inspect a file safely, open it through Excel's import dialog and select UTF-8, or use a plain-text editor. Never re-save the import file over the original. For the broader list of formats verifiers accept, see what file formats email verifiers accept.
Bottom line: Export CSV for imports, Excel for eyeballing, and JSON for code. Keep the import file out of Excel's save cycle.
How do you export valid emails step by step?
Run these seven steps after every verification. On a list of a few thousand rows, the first five take about ten minutes.
- Confirm the run has finished. Check that every uploaded row has a result before you export anything. Exporting mid-run gives you a partial Valid file that looks complete.
- Record the three counts. Note the number of Valid, Risky and Invalid rows from the summary. You'll need them for reconciliation.
- Download the Valid file as CSV. Name it with the date, the source and the word "valid", for example
2025-06_webinar-leads_valid.csv. Clear names matter when you have a dozen exports from the same month. - Reconcile the totals. Valid + Risky + Invalid must equal your input row count. If they don't, use the table in the next section to find the cause before going further.
- Inspect the file in a plain-text viewer. Confirm there is one header row, every data row contains an
@, there are no blank lines, and the row count matches your Valid number. - Deduplicate and normalise. Trim spaces and lowercase each address, then remove duplicates. Lowercasing is the practical choice for marketing lists. Strictly, the local part of an address may be case-sensitive under RFC 5321, but mailbox providers treat common addresses case-insensitively, so lowercasing rarely causes a real delivery problem. Log how many duplicates you removed.
- Restore your identifying columns. The results file may not include your original fields, such as name, company or signup source. Join the Valid addresses back to the source file using a row identifier, not the email column alone. Our guide to keeping custom fields when verifying a list shows how.
The row identifier in step 7 is worth adding before you upload anything. Add a column called row_id with a sequential number to your source file. Emails get trimmed, lowercased and deduplicated during cleaning, so joining on the email column can silently drop or mismatch rows. A numeric ID survives all of that. How to clean a messy CSV of emails before upload covers the preparation steps.
Bottom line: Reconcile the counts before you trust the export, and restore your original fields by ID before you import.
Why doesn't the Valid count match my input rows?
A mismatch almost always comes from the source file's structure, not from the verifier. Find the cause in the table below before you re-run anything.
| Symptom | Likely cause | Fix |
|---|---|---|
| Buckets add up to fewer rows than the input | Blank lines, or a quoted line break in a field, that the parser treated as a separate or merged record | Locate the gap using row_id, clean the source file, and re-upload |
| Buckets add up to more rows than the input | A repeated header row or a stray delimiter splitting one record into two | Check the header count and re-save the source as UTF-8 CSV |
| Export file has fewer rows than the Valid count | A tool dropped rows on re-save, or the download was partial | Re-download directly from the results page and never save over the export |
| Valid count changes between two runs on the same list | Mail servers can respond differently from one check to the next, so a small share of addresses, often Risky ones, can move between buckets | Treat the most recent run as current, and log the change |
The last row catches people off guard. Verification reflects what mail servers say at the time of checking. A small shift between runs is normal, and it's the reason to re-verify before a major send rather than relying on a file that's weeks old.
Bottom line: A count mismatch is a file-structure problem nine times in ten. Use row_id to find the rows that went missing.
How do you export valid emails with a script or the API?
Use a script when lists recur, when you verify more than 25,000 rows at a time on Pro, or when verification runs inside your own system. The email verification API accepts single-email checks and bulk batches of up to 10,000 emails per request. API access is included on Pro, which covers 100,000 emails a month. The Free plan doesn't include API access.
For a broader view of how verification fits into automated workflows, see email verification API and automation.
Here is a minimal filter for a results file exported as CSV. Replace status and valid with the column name and label your file actually uses:
import pandas as pd
results = pd.read_csv("results.csv", dtype=str, encoding="utf-8")
status = results["status"].str.strip().str.lower()
valid = results[status == "valid"]
valid.to_csv("valid_only.csv", index=False, encoding="utf-8")
print(len(valid), "valid rows exported")
Reading with dtype=str stops pandas from converting values such as ZIP codes or IDs, and the explicit encoding prevents character corruption. The pandas library is a widely used open-source option, but any tool that reads and writes UTF-8 CSV will do. Print the row count and compare it with your dashboard before importing.
Bottom line: Scripts make exports repeatable at volume. Always print the count and check it against the dashboard before the file leaves your system.
Worked example: exporting valid emails from an 84,300-row list
This example is illustrative. The plan limits and arithmetic are real, but the verification results are hypothetical.
Scenario: A SaaS company exports 84,300 contacts from its CRM and needs only the valid addresses for a product announcement. For context on why SaaS lists churn so quickly, see email verification for ecommerce and SaaS.
Step 1: Split the file to fit the Pro list cap. Each list on Pro can hold up to 25,000 emails. Use splitting a large CSV for verification to produce four files:
25,000 + 25,000 + 25,000 + 9,300 = 84,300 rows
Step 2: Budget the deep checks. Pro includes 25,000 deep verifications a month. If every row needed one, the team would exceed the allowance by 84,300 − 25,000 = 59,300. Instead, it deep-checks its 18,000 oldest contacts, which uses 18,000 of the 25,000 allowance and leaves 7,000 for spot-checks. Standard verification is unlimited on every plan, so the remaining rows still get checked.
Step 3: Results (hypothetical).
- Valid: 69,510 (82.4%)
- Risky: 9,870 (11.7%)
- Invalid: 4,920 (5.8%)
Reconciliation: 69,510 + 9,870 + 4,920 = 84,300. The totals match the input, so the team proceeds.
Step 4: Export and merge. The team downloads four Valid files, one per part, deduplicates them and merges them into a single send list. Invalid addresses go to the suppression file, and Risky addresses go to a held segment.
Step 5: The API alternative. Verifying the same 84,300 rows by script would take 9 requests: eight batches of 10,000 and one of 4,300. That's well within the 100,000 API emails a month on Pro, and it leaves 100,000 − 84,300 = 15,700 for the rest of the month.
Cost: One Pro month is $29, or $25 a month on the annual plan. The standard verification itself carries no per-email fee. For how pricing models compare across the category, see email verification pricing.
Bottom line: Split files to fit the list cap, budget deep checks separately, and reconcile the totals before exporting Valid.
Worked example: exporting valid emails on the Free plan
This example is also illustrative. The limits are from the Free plan.
Scenario: A freelancer has a 1,200-row list from a workshop sign-up form.
- Splitting: The Free plan allows up to 150 emails per list. That means 1,200 ÷ 150 = 8 files.
- Monthly budget: The Free plan allows 25 lists a month, so this run uses 8 of them. The maximum the plan can handle in a month is 25 × 150 = 3,750 emails, so the freelancer has room for about three more runs of this size.
- Deadline: Results are kept for 24 hours on Free. The freelancer runs all eight files in the morning and exports the Valid results before the end of the day.
- Deep checks: Free includes 750 deep verifications a month. The freelancer deep-checks the 150 most recent sign-ups and uses standard verification for the rest.
Use the free email checker to spot-check a few addresses, or sign up for a free account to run the full list.
Bottom line: On Free, the 24-hour retention window matters more than the cost. Plan the export into the same session as the verification.
What should you do with the Risky and Invalid files?
Suppress the Invalid file permanently and hold the Risky file out of your main sends. Both steps protect your sender reputation, but they serve different purposes.
For Invalid, the reasoning is simple. These addresses failed checks, and mailing them creates bounces. Import them into your platform's suppression list before you import the Valid file. Handling invalid addresses after list cleaning covers how to keep them out permanently.
For Risky, the reasoning is more cautious. Catch-all and role-based addresses can still belong to real people, so you can't rule them out, and mailing the whole group at once risks bounces you can't predict. Test in small slices, starting with the most engaged contacts. A practical rule is to pause a slice if its bounce rate passes 2%, the ceiling many teams use, and review before continuing.
If your Invalid share is unusually high, the cause is upstream. When 30 percent of a list is invalid walks through how to find the source, such as a stale import or a form without validation.
Bottom line: Suppress Invalid before anything else, and test Risky in small, engagement-ranked slices.
How do you import the valid file without re-adding bad contacts?
Import the suppression file first, then import the Valid file into a new segment, then point your sends at that segment. Many platforms offer a choice between creating new contacts and updating existing ones, and that choice decides whether invalid addresses come back.
The safest sequence is:
- Import Invalid addresses into the suppression list. Do this first, so nothing you import later can reach those addresses.
- Import Valid addresses into a new list or segment. Don't write them over your master list.
- Confirm the segment count matches your Valid number. A mismatch here usually means the import deduplicated or rejected rows, so find out why before sending.
- Point future campaigns at the new segment. Retire the old master list only after you've run one clean send and checked the bounce rate.
Because the suppression list is already in place, this order also makes later re-imports safer. The platform's own import options vary, so check its documentation for how it handles duplicates and suppressed contacts. For ongoing maintenance, email list maintenance best practices explains how to schedule these re-checks. If you're moving toward checks at the point of signup, real-time email validation prevents many invalid addresses from entering the list at all.
Bottom line: Suppress first, import Valid into a new segment, and retire the old master list only after the counts and first send check out.
How do you check the export is complete?
Run four checks before importing: row count, format, duplicates and a sample check. On a list of tens of thousands of rows, all four take under ten minutes.
- Row count: The Valid file's row count should match the Valid number on your results summary. If it doesn't, return to the reconciliation table above.
- Format: Each row should contain one address and one
@, with no leading spaces or hidden characters. A quick search for non-printing characters catches most copy-paste problems. - Duplicates: After lowercasing, the unique address count should equal the row count, or you should know exactly how many duplicates were removed.
- Sample check: Pick 20 random addresses from the Valid file and check them with the free email checker. A 20-address sample can catch gross errors, such as a wrong column or a shifted file, but it can't validate 69,000 rows. Treat it as a sanity check on the file, not a substitute for verification.
Unlimited Verifier states 99.5% accuracy for deep verification. That is the company's own figure, not an independent benchmark, so the sample check still matters on high-stakes lists. To learn what each column in the results file means, see how to read an email verification results file.
Bottom line: Four quick checks catch most export errors before they reach your email platform.
What mistakes ruin a valid-email export?
Most export failures come from timing, re-saving or re-importing the wrong file.
- Missing the retention window. Results are kept 24 hours on Free and 30 days on Pro. Exporting after the window closes means re-verifying the list, which costs time and possibly deep-check allowance.
- Skipping the count check. A few hundred missing rows usually points to a parsing problem, and it's easy to miss without reconciliation.
- Re-importing the master file. Uploading the original list back into your platform reintroduces every address you just removed.
- Re-saving the import file in Excel. This can change delimiters or corrupt characters, and the damage often shows up only as a bounce spike later.
- Sending Risky with Valid. Catch-all and role-based addresses belong in a tested segment, not in the main send.
- Losing identifying columns. An export with addresses alone makes personalisation and segmentation harder later. Use a
row_idto keep the join reliable. - Treating Valid as consent. Verification confirms that an address can receive mail. It can't confirm that the person agreed to hear from you. The FTC's CAN-SPAM compliance guide sets out baseline obligations for commercial email in the US. For the wider picture, see email verification compliance and hygiene.
- Forgetting the suppression file. Without one, the same invalid addresses return with every new import.
Bottom line: Most export problems are preventable with a dated file, a count check and a suppression list.
How we compared (and limitations)
This guide draws on public documentation: the RFCs for CSV, SMTP and UTF-8, the FTC's CAN-SPAM guidance, and Unlimited Verifier's published plan details. We haven't tested every email platform's import behaviour, and import options differ by provider, so confirm settings in your platform's documentation before relying on them.
The 84,300-row and 1,200-row examples are illustrative. The plan limits, retention periods and arithmetic are real, but the verification results are hypothetical. Unlimited Verifier states 99.5% accuracy for deep verification. That figure comes from the company, not from an independent test.
If you're comparing verifiers on export features, our guides to the best email verification tools and how to choose an email verifier set out what to check. To see how the export fits into the full process, start with the bulk email list verification workflow. If you're ready to try it, upload and verify a list with your own file. For a step-by-step guide to the upload itself, see how to upload a CSV to an email verifier. Once the Valid file is ready, how to segment a list by verification status shows how to turn the three buckets into working segments.
Bottom line: Use the examples as a template, confirm import behaviour on your own platform, and keep the dated Valid file as your single source of truth.
Export and reconcile steps
- Verify the full list.
- Download only the Valid bucket as CSV, Excel or JSON, same day.
- Check Valid + Risky + Invalid = uploaded row count.
- Import the suppression file (Invalid) first.
- Import the dated Valid file as your send list.
- Hold Risky addresses in a separate segment for small tests.
Frequently asked questions
How do I export only valid emails?
Open your verification results and download the Valid bucket on its own as CSV, Excel or JSON. Do not export the full result set and filter later, because that mixes buckets. Save the file with a date stamp so it serves as your send list.
How long do I have to export verification results?
Results are kept for a limited time that depends on your plan. Per the article, Unlimited Verifier keeps results 24 hours on Free and 30 days on Pro, so export the same day you verify to avoid losing them.
Should I include Risky emails in my export?
No. Keep Risky addresses in a separate held segment rather than your main Valid file. Catch-all domains accept mail for any address, so a Risky result cannot confirm the mailbox exists.
Why do my Valid, Risky and Invalid counts not match my upload?
A mismatch usually means some rows were dropped during upload, were duplicates, or were formatted incorrectly. Check the row count, fix the source file, and re-verify before trusting the export.
What format should I export valid emails in?
Use CSV for most email platform and CRM imports, Excel for manual review, and JSON for scripts or API workflows. Pick the format your destination accepts without manual reformatting.
Can I just delete invalid rows from my master list?
You can, but it erases the record of what was removed and makes it easy to re-import bad addresses later. Keep a separate Invalid file for suppression and leave the original master list untouched.
Do I need to suppress invalid emails before importing?
Yes. Import your suppression file first, or invalid contacts may return through your original master list during a sync or re-upload.
How often should I export and re-verify my email list?
Re-verify whenever a list is reused or aged, and before major campaigns. Each new Valid export should carry its own date so you can show which addresses passed at a given time.
Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification
Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.
| Free | Pro | |
|---|---|---|
| Price | $0 | $29/month ($25/month billed annually) |
| Lists | 25 a month, up to 150 emails each | Unlimited, up to 25,000 emails each |
| Deep verifications | 750 a month | 25,000 a month |
| API access | No | Yes (100,000 emails a month) |
| Result retention | 24 hours | 30 days |
Why teams choose Unlimited Verifier
- Unlimited standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
Unlimited Verifier states 99.5% accuracy for deep verification.
Create a free account and verify your next list before you hit send.
Want to test a single address first? Try the free email checker.