Learn simple, fast methods to extract emails and URLs from any text using free tools, regex, Google Sheets, Python, and online utilities. Step-by-step examples make it easy for beginners and pros.

I once inherited a messy contact list stored inside a single long text file. Manually picking out emails and web links took hours. After I learned a few tricks—regular expressions, a quick Google Sheets formula, and a tiny Python script—I pulled every email and URL from that file in minutes. If you want the same speed and reliability, this guide shows every practical method, from no-code tricks to lightweight code you can run on your computer.

Why extracting emails and URLs matters

Collecting emails and URLs from text is a common task for content audits, outreach campaigns, research, and cleaning old data. Doing it by hand risks typos and missed items. Automated or semi-automated methods save time, avoid errors, and let you focus on what matters: contacting people or analyzing links. This guide covers tools and techniques that work on any operating system and require minimal setup.

Quick safety and legal reminder

Before extracting emails or URLs from any source, make sure you have the right to use that data. Harvesting contact details from private lists or scraping websites without permission can violate terms of service and privacy laws. Use this guide for lawful tasks: cleaning your data, organizing public lists, or working with content you own or are allowed to process.

Method 1 — Use a reliable online extractor (zero coding)

If you don’t want to write code, many free online utilities let you paste text and instantly output emails and links. These tools usually offer copy-to-clipboard and CSV export, and they work well for one-off jobs or short texts.

How to use them:

1. Open the extractor page in your browser.
2. Paste the text into the input box.
3. Click the extract button.
4. Review and export the results as CSV or plain text.

Tips: paste only text you control, and don’t upload sensitive files to unknown sites. If you work with confidential lists, use offline methods below.

Method 2 — Extract with Google Sheets (no code, fast for lists)

Google Sheets is great when you want to extract and organize results into a spreadsheet instantly. It works well for medium-size texts and offers easy formulas.

Extract emails from a text cell (example where A1 contains the text):

=ARRAYFORMULA(REGEXEXTRACT(SPLIT(A1," "), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"))

A simpler, robust approach to extract all emails from a cell range:

1. Put your long text into a single cell (A1).
2. Use:

=TRANSPOSE(SPLIT(REGEXREPLACE(A1,"[^A-Za-z0-9@._%+-]+"," "), " "))

1. Then filter with:

=FILTER(TRANSPOSE(SPLIT(REGEXREPLACE(A1,"[^A-Za-z0-9@._%+-]+"," "), " ")), REGEXMATCH(TRANSPOSE(SPLIT(REGEXREPLACE(A1,"[^A-Za-z0-9@._%+-]+"," "), " ")), "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"))

Extract URLs from a cell:

=ARRAYFORMULA(REGEXEXTRACT(SPLIT(A1," "), "https?://[^\s,]+"))

Why Sheets is good:

• No installation required.
• Results immediately in a spreadsheet you can edit and export.
• Great for moderate-sized lists and quick cleaning.

Method 3 — Use Excel with formulas (Windows or Mac)

Excel supports regular expressions via newer versions (Office 365/Excel 2021) with LET and TEXTSPLIT or via VBA for older versions.

Simple Excel approach using TEXTSPLIT and FILTER (if available):

1. Put text in A1.
2. Split into words:

=TEXTSPLIT(A1," ")

1. Filter emails:

=FILTER(TEXTSPLIT(A1," "),ISNUMBER(SEARCH("@",TEXTSPLIT(A1," "))))

If your Excel lacks these functions, use a small VBA macro to extract matches with regex. VBA example (paste into a module):

Function ExtractMatches(text As String, pattern As String) As String
    Dim re As Object, matches As Object, m As Object
    Set re = CreateObject("VBScript.RegExp")
    re.Global = True
    re.Pattern = pattern
    Set matches = re.Execute(text)
    Dim out As String
    For Each m In matches
        out = out & m.Value & vbNewLine
    Next
    ExtractMatches = out
End Function

Call it from a cell:
 =ExtractMatches(A1, "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")

Method 4 — Regular expressions you can copy and use

Regular expressions (regex) are the most flexible way to extract patterns. Below are practical regex patterns that work in most tools and programming languages.

Reliable email regex (balanced between correctness and practicality):

[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}

Common URL regex (matches http(s) links):

https?://[^\s'">]+

URL regex that also matches www
. links (no protocol):

((https?://)|(www\.))[^\s'">]+

If you use an environment that supports lookarounds and more advanced features, you can use stricter patterns. But the above are safe, fast, and work in nearly every real-world case.

Method 5 — Use a lightweight Python script (best for large files)

Python is perfect when you need to extract from large text files, process directories, or automate recurring jobs. The following script extracts emails and URLs and writes them to CSV.

import re
import csv
from pathlib import Path

# Patterns
email_re = re.compile(r'[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}')
url_re = re.compile(r'https?://[^\s\'">]+')

def extract_from_text(text):
    emails = set(email_re.findall(text))
    urls = set(url_re.findall(text))
    return sorted(emails), sorted(urls)

def process_file(file_path, out_csv):
    text = Path(file_path).read_text(encoding='utf-8', errors='ignore')
    emails, urls = extract_from_text(text)
    with open(out_csv, 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f)
        writer.writerow(['type','value'])
        for e in emails:
            writer.writerow(['email', e])
        for u in urls:
            writer.writerow(['url', u])
    print(f"Saved {len(emails)} emails and {len(urls)} urls to {out_csv}")

if __name__ == "__main__":
    import sys
    if len(sys.argv) < 3:
        print("Usage: python extract.py input.txt output.csv")
    else:
        process_file(sys.argv[1], sys.argv[2])

How to run:

1. Save as extract.py.
2. python extract.py input.txt output.csv

Why python is useful:

• Handles very large files.
• Easy to tweak regex and output format.
• Automates repeated tasks and batch processing.

Method 6 — Command-line one-liners (grep, sed, awk) for power users

If you use Linux or macOS, command-line tools are lightning-fast.

Extract emails from file.txt:

grep -oE '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}' file.txt | sort -u > emails.txt

Extract URLs:

grep -oE 'https?://[^ ]+' file.txt | sort -u > urls.txt

On Windows with PowerShell:

Select-String -Path file.txt -Pattern '\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b' -AllMatches |
ForEach-Object { $_.Matches } | ForEach-Object { $_.Value } | Sort-Object -Unique

These commands are ideal for log files, server output, or when working inside a terminal.

Method 7 — Clean and deduplicate results

After extraction you’ll often want a clean list without duplicates or malformed entries. Common steps:

1. Normalize whitespace and remove trailing punctuation.
2. Remove duplicates (use sort -u or set in Python).
3. Validate domain existence for critical email lists if needed (optional step).
4. Export to CSV for import into tools like Mail clients or CRMs.

Example Python snippet to clean up emails:

cleaned = []
for e in emails:
    e = e.strip().strip('.,;:()<>[]')
    if '@' in e and '.' in e.split('@')[-1]:
        cleaned.append(e.lower())
unique = sorted(set(cleaned))

Method 8 — Verify before using (optional but recommended)

If you plan to use extracted emails for outreach, verify them to reduce bounce rates. Basic verification steps:

• Syntax check (regex).
• Domain check (DNS MX record lookup).
• Mailbox existence check (use reputable verification services if allowed).

Be careful with verification tools and respect privacy laws. Never send unsolicited bulk emails to lists you scraped.

Method 9 — Extracting from PDFs and images

Text embedded in PDFs or images needs OCR (optical character recognition). Use a two-step approach:

1. Convert PDF to text or image to text using OCR.
2. Run your regex or extraction method on the OCR output.

Free tools and libraries:

• Tesseract OCR (open source) for images and scanned PDFs.
• pdftotext for many native PDFs that contain text.

Basic Tesseract example (command line):

tesseract scan.png output -l eng
# then process output.txt with your regex

OCR accuracy depends on scan quality and layout. Proofread extracted results, especially for emails where characters like @ or . may be misread.

Method 10 — Automate the workflow

If you find yourself extracting regularly, automate:

• Watch a folder and process new files with a script.
• Create a Google Sheets button (Apps Script) to run regex on pasted text.
• Build a small desktop shortcut or batch file that runs the Python script.

Automation saves time and standardizes results when processing many documents.

Common pitfalls and how to avoid them

Mistakes to watch for:

• False positives: numbers or text that match pattern but aren’t real (e.g., user@localhost). Filter domains with a dot and reasonable TLD length.
• Overly strict regex: misses valid but unusual addresses. Use pragmatic regex that balances recall and precision.
• Sensitive data exposure: never upload private lists to unknown services. Prefer offline or trusted tools.
• OCR errors: always validate outputs from scanned documents.

Practical fixes: normalize results, use domain checks, and always review before action.

Practical examples and use-cases

1. Audit old newsletters: extract all recipient emails from an exported text file to rebuild lists (with permission).
2. Content research: pull all outbound links from competitor content to analyze sources.
3. Website migration: extract author emails and contributor links for new site setup.
4. Event follow-up: quickly capture emails from registration forms exported as raw text.

These examples show how the methods above translate directly into time saved and fewer mistakes.

Quick checklist to follow every time

• Confirm you have the right to extract and use the data.
• Pick the extraction method that fits size and sensitivity of data.
• Use regex patterns provided (email and URL).
• Clean and deduplicate results.
• Verify important emails before outreach.
• Store results securely and respect privacy.

Final thoughts

Extracting emails and URLs from text is an essential skill that becomes trivial with the right approach. For one-off jobs, online extractors or Google Sheets do the trick. For recurring or large-scale work, a small Python script or command-line pipeline is reliable and fast. Always prioritize privacy and legal use, clean your results, and verify before acting on contact data. Try the methods in this guide on a test file and you’ll be amazed how much time you can save compared with manual copying.

If you want, I can create a ready-to-publish blog post version of this guide with do