How to Scrape Emails From a Website
(legal and ethical guide for 2026)

Open the contact, about, or team page. Press Cmd+F (Ctrl+F on Windows) and search for "@". Most contact pages will surface the addresses immediately. For addresses tucked into the page source but not visually rendered, right-click and choose View Page Source, then search for "mailto:" or "@".

This works on roughly 60 percent of small business websites and almost no enterprise sites. The ceiling is hit fast, but for one-off research it is a zero-tool, zero-friction option.

A handful of Chrome extensions walk the DOM, extract every email address on a page, and dump them into a CSV. Hunter, Apollo, Lusha, and Snov.io all ship one. They are convenient for browsing-and-scraping workflows where you are already on a prospect's site reading.

Trade-off: extensions pull addresses already visible on the page. They do not infer the head of marketing's email from the careers page. They also draw from the vendor's database, so what you get is a hybrid of "scraped from this page" and "matched from our database". Read the extension's behaviour carefully before relying on it.

The fastest method for a single page. Open Chrome DevTools (Cmd+Option+I), switch to the Console tab, and paste:

const emails = document.body.innerHTML.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g);
console.log([...new Set(emails || [])]);

You will get a deduplicated array of every address that appears anywhere in the rendered HTML, including JSON-LD blocks, hidden mailto links, and inline scripts. View Source misses the JavaScript-injected ones. DevTools does not.

For sites that load content dynamically (single-page apps), wait until the page settles before running the snippet. For obfuscated addresses (more on that below), this regex catches the cleartext ones and misses the rest.

The classic scraping stack. 30 lines of Python, runs on a laptop, handles multiple pages per domain (contact, about, team), and writes results to a CSV. Here is a working starter:

import re, csv, requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin

EMAIL_RE = re.compile(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}")
CONTACT_PATHS = ["/", "/contact", "/contact-us", "/about", "/team"]
HEADERS = {"User-Agent": "Mozilla/5.0 (compatible; ResearchBot/1.0)"}

def scrape_domain(domain):
    found = set()
    for path in CONTACT_PATHS:
        url = urljoin(f"https://{domain}", path)
        try:
            r = requests.get(url, headers=HEADERS, timeout=10)
            if r.status_code != 200: continue
            soup = BeautifulSoup(r.text, "html.parser")
            found.update(EMAIL_RE.findall(soup.get_text()))
            for a in soup.find_all("a", href=True):
                if a["href"].startswith("mailto:"):
                    found.add(a["href"].replace("mailto:", "").split("?")[0])
        except Exception as e:
            print(f"skip {url}: {e}")
    return found

if __name__ == "__main__":
    domains = ["acme.com", "example.com"]
    with open("emails.csv", "w", newline="") as f:
        w = csv.writer(f)
        w.writerow(["domain", "email"])
        for d in domains:
            for e in scrape_domain(d):
                w.writerow([d, e])

What this gets you: every public-facing address listed on the contact, about, and team pages of each domain. What it does not get you: JavaScript-heavy sites that render emails client-side (use Playwright for those), obfuscated addresses, and decision makers who do not list themselves publicly.

Add rate limiting (a one-second sleep between requests) and respect robots.txt. Scraping responsibly keeps your IP off blocklists.

At a certain point, scraping the website is the wrong tool. The contact page does not list the Head of Sales. The team page does not list anyone in engineering. The about page links to LinkedIn. Scraping captures what is there, which is rarely what you want.

The inversion: use a SaaS tool that takes a domain and either returns the pattern (firstname@domain, firstname.lastname@domain) or returns the verified address for a named person at that company. You skip scraping entirely and get directly to the address.

Two relevant tools:

• arrow_rightEmail Finder: enter a name and company domain, get a verified email back.
• arrow_rightEmail Pattern Detector: enter a domain, get the company's email pattern back. Generate any address you need from there.

For most B2B prospecting use cases, this path produces a cleaner list in a fraction of the time. You will scrape less, send to better addresses, and spend less time cleaning up bounces.