Pull every email address out of messy text, exports, or logs into a deduplicated, alphabetized list separated by lines, commas, or semicolons.
Content last reviewed
0 characters · 0 words
Drop in anything — meeting notes, CRM exports, document text — into the left panel.
Choose one address per line, comma-separated, or semicolon-separated in the sidebar.
Unique addresses appear sorted A–Z on the right — copy them or download the .txt file.
Addresses are found inside sentences and angle brackets, duplicates that differ only in case are merged, and the result is sorted A–Z.
Input
John Doe <john.doe@northwind.co.uk> confirmed; cc mary@northwind.co.uk. Billing goes to accounts@vendor.io. Old contact JOHN.DOE@northwind.co.uk is the same person.Output
accounts@vendor.io
john.doe@northwind.co.uk
mary@northwind.co.ukThe same extraction with the comma separator selected.
Input
john.doe@northwind.co.uk, then later mary@northwind.co.uk appears again: mary@northwind.co.ukOutput
john.doe@northwind.co.uk, mary@northwind.co.ukEmail addresses have a way of hiding inside other text: scattered through meeting notes, buried in CRM exports, mixed into signatures and forwarded threads. Picking them out by hand is slow and error-prone. This extractor scans whatever you paste, finds every properly formatted address, and returns a clean list — lowercased, deduplicated, and sorted alphabetically.
The extraction happens live as you paste. A sidebar counts the unique addresses and the number of distinct domains, which is a quick sanity check that the scan caught what you expected. You choose how the list is joined: one address per line for spreadsheets and reviews, comma-separated for Gmail's recipient field, or semicolon-separated for Outlook. The result can be copied to the clipboard or downloaded as a text file.
Copy the source text — an email thread, a document, an export — and paste it into the Raw text panel. Click Try an example to see the extraction with sample text first.
Extraction runs automatically: every valid address is lowercased, duplicates are collapsed, and the list is sorted A–Z in the Extracted addresses panel.
Check the sidebar counts of Unique addresses and Domains against what you expected from the source.
Choose the Output format — one per line, comma, or semicolon. Semicolons paste straight into Outlook; commas into Gmail.
Copy the result or download it as email-addresses.txt.
Addresses are found the moment you paste — no scan button, no settings required.
Addresses are lowercased so JOHN@ and john@ collapse into one entry, then sorted alphabetically.
One per line for spreadsheets, comma-separated for Gmail, semicolon-separated for Outlook.
Live statistics show how many unique addresses and distinct domains were found.
Send the list to the clipboard or save it as a .txt file.
Pull every address out of a long forwarded thread to reconstruct who was involved.
Extract just the addresses from an export where they are mixed with names and other fields.
Turn scattered contact notes into a clean, deduplicated column for a spreadsheet.
Check what email addresses a document or page of text exposes before sharing it.
Convert a line-based list into the comma or semicolon format your email client expects.
The extractor scans your text with a pattern that matches the standard shape of an email address: a local part of letters, digits, and common punctuation, an @ sign, and a domain ending in a top-level domain of at least two letters — name@domain.tld. Everything around a match (names, brackets, sentence punctuation) is ignored.
Matches are then normalized to lowercase, which both standardizes the list and lets differently cased copies of the same address collapse during deduplication. The unique set is sorted alphabetically and joined with your chosen separator. The domain count in the sidebar is derived by taking the part after the @ in each unique address. All of this reruns automatically every time the input changes.
Any pasted text — notes, threads, CSV rows, code, or document content. Formatting is ignored; only the address patterns matter.
Newline-, comma-, or semicolon-separated lists, plus a .txt download of the current output.
One per line (default), comma-separated, or semicolon-separated — switchable at any time without re-pasting.
Loads a sample block of notes so you can see the extraction behavior.
Drag the divider between input and output, or expand either panel fullscreen for large pastes.
Deliberately disguised addresses — name (at) domain dot com — do not match the standard pattern and are skipped. Restore the @ and dots, then re-paste.
Copies of the same address in different capitalization merge into one lowercase entry. The Unique addresses count reflects the deduplicated total, not raw occurrences.
Anything shaped like an address is extracted, including decommissioned or misspelled ones — the tool cannot verify that a mailbox exists. Skim the list before using it.
Extraction is pattern-based, not verification: it cannot confirm a mailbox exists, and it will pick up validly shaped addresses that are stale or fictional. Disguised addresses (name at domain dot com) and addresses broken across lines are not detected. Unusual but technically valid addresses — quoted local parts or internationalized domains in non-Latin scripts — fall outside the standard pattern. Output is always lowercased and alphabetized, so source order and capitalization are not preserved. Processing happens in memory in your browser, which comfortably handles typical documents and exports.
Everything runs locally in your browser: the text you paste and the addresses extracted from it are never uploaded, logged, or stored by the tool. Since contact data is personal data, only process text you have a legitimate reason to handle — the tool is intended for organizing your own contacts, not for harvesting or building unsolicited mailing lists.
Skim the output for stale or misspelled addresses — the extractor finds patterns, it cannot verify mailboxes.
Pick the separator to match the destination: semicolons for Outlook, commas for Gmail, lines for spreadsheets.
Repair obfuscated addresses (at/dot spelled out) in the source text before extracting.
Only extract addresses you are authorized to process, and respect anti-spam laws like GDPR and CAN-SPAM.
Keep the source text until you have confirmed the extracted list is complete.
Paste generously — the extractor ignores everything that is not an address, so including the whole document costs nothing and reduces the chance of missing entries scattered in footers and signatures. Then compare the sidebar counts against your rough expectation: two addresses from a fifty-person thread means the source probably obfuscates addresses or the paste was partial.
Review before you use. Automated extraction is honest about shape but blind to meaning: it happily includes a decade-old address from a quoted signature. A quick skim, sorted A–Z as the list already is, catches obvious strays.
Finally, treat the result as personal data. Store it somewhere appropriate, use it for the purpose you collected it for, and avoid pasting extracted lists into services you would not trust with your own address book.
Extraction runs client-side with a single regular expression pass matching the conventional local-part@domain.tld shape (letters, digits, and ._%+- in the local part; a domain with at least a two-letter TLD). Matches are lowercased, deduplicated via a Set, and sorted with a standard string sort. The domain statistic counts distinct strings after the @ among unique addresses. Output joining and the .txt download are also generated locally; no network request carries your text.
Office workers reconstructing recipient lists from long threads, marketers and admins cleaning exports from CRMs and form tools, recruiters and event organizers consolidating contact notes, and anyone auditing a document for exposed addresses before sharing it. It suits one-off cleanups where opening a spreadsheet and writing formulas would be overkill.
It matches the standard name@domain.tld pattern — letters, digits, and common punctuation before the @, then a domain ending in a top-level domain of at least two letters. Surrounding words, brackets, and punctuation are ignored.
No. Deliberately disguised addresses do not match the standard pattern, so they are skipped. Restore the @ and dots in the source text if you need those extracted.
Addresses are normalized to lowercase so that differently cased copies of the same address — JOHN.DOE@ and john.doe@ — collapse into a single entry. Email delivery is unaffected, since domains are case-insensitive.
No. Extraction is purely pattern-based; it cannot tell a live mailbox from a retired or fictional one. Review the list, and use a dedicated verification service if deliverability matters.
Match your destination: one per line pastes cleanly into spreadsheet columns, commas suit Gmail's recipient fields, and semicolons suit Outlook.
Only within the rules that apply to you. Laws such as GDPR and CAN-SPAM restrict unsolicited email, and this tool is intended for organizing contacts you already have a lawful basis to use — not for building cold mailing lists.
No. Extraction runs in your browser, and neither the pasted text nor the resulting list is uploaded or stored. Closing the page discards everything.