How to Extract Emails from a Website (via URL)

← Back to Email Extractor

Scope of this guide: how to extract emails from a website – live pages and URLs you access over the web. If you already have the page’s markup saved locally, our guide to extract emails from HTML source code covers that case in depth.

Why Websites Contain Email Addresses

Websites are one of the richest sources of publicly shared email addresses. Organizations and individuals publish their contact information in many places across a website:

• Contact pages – dedicated contact sections almost always list one or more email addresses for inquiries, support, or sales.
• Footer sections – many websites include a general contact email in the site-wide footer, visible on every page.
• About and team pages – company team pages often list individual email addresses for each team member or department.
• Job listings – career pages and job postings frequently include an HR or hiring manager email for applications.
• Legal and impressum pages – in many countries (especially in Europe), businesses are legally required to publish contact details including email on their impressum or legal notice page.
• Blog posts and articles – author bios, guest contributor credits, and press releases often contain email addresses.

Manually browsing through every page of a website to collect email addresses is tedious and easy to miss. The methods below automate this process.

Method 1: Copy-Paste from a Website

The simplest approach requires no tools or programming knowledge. It works for any web page you can view in a browser.

1. Navigate to the web page containing email addresses.
2. Select all visible text with Ctrl+A (Windows/Linux) or Cmd+A (macOS).
3. Copy the selected text with Ctrl+C / Cmd+C.
4. Go to extract-emails.com and paste the text into the input field.
5. The tool instantly identifies and lists every email address found in the pasted text.

Limitation: This method only captures text visible on the current page. It does not follow links to other pages, and email addresses hidden in the HTML source (e.g., mailto: links behind buttons) may not be included.

Method 2: Use Our Browser-Based Tool (Recommended)

Our tool at extract-emails.com can process large blocks of text pasted from one or multiple web pages. For the best results:

1. Visit the pages you want to extract emails from.
2. Use Ctrl+U (View Source) to access the full HTML source code, which may contain email addresses not visible on the rendered page.
3. Copy the source and paste it into our tool.
4. The tool strips all HTML tags and applies a regex pattern to find every email address, including those in mailto: links, meta tags, and JavaScript variables.
5. Results are deduplicated and displayed instantly. Copy them or download as a file.

Scan contact pages on the same site

Open the extractor, enter a public HTTP(S) URL and allow the URL request. “Scan contact pages” checks robots.txt, uses the sitemap when available, and follows relevant internal links to contact, imprint, team and legal pages. It attempts no more than 20 pages on the same website and shows each address with its source page.

Common masking such as info(at)example.com or info [at] example [dot] com is recognized. The tool warns when image filenames or alternative text suggest a possible email graphic. It does not read text inside images, run the target page’s JavaScript or sign in to a site.

Pasted text and imported files are processed locally. Up to five extractions are stored in this browser until deleted; large results are not saved. Public URL retrieval uses this website’s hosting, and DNS tools query Cloudflare. Analytics and partner tracking depend on your consent.

Method 3: Python with Beautiful Soup

For developers who need to extract emails from multiple pages or automate the process, Python with the Beautiful Soup library is the standard approach.

Basic Single-Page Extraction

Install dependencies and extract emails from a URL

pip install beautifulsoup4 requests

import re
import requests
from bs4 import BeautifulSoup

def extract_emails_from_url(url):
    response = requests.get(url, timeout=10)
    soup = BeautifulSoup(response.text, "html.parser")

    # Get all visible text
    text = soup.get_text()

    # Also check mailto: links
    for link in soup.find_all("a", href=True):
        if link["href"].startswith("mailto:"):
            text += " " + link["href"].replace("mailto:", "")

    pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
    emails = list(set(re.findall(pattern, text)))
    return sorted(emails)

# Example usage
emails = extract_emails_from_url("https://example.com/contact")
for email in emails:
    print(email)

Crawling Multiple Pages

To extract emails from an entire website, you can follow internal links and visit each page:

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

def crawl_and_extract(start_url, max_pages=50):
    domain = urlparse(start_url).netloc
    visited = set()
    to_visit = [start_url]
    all_emails = set()
    pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'

    while to_visit and len(visited) < max_pages:
        url = to_visit.pop(0)
        if url in visited:
            continue
        visited.add(url)

        try:
            response = requests.get(url, timeout=10)
            soup = BeautifulSoup(response.text, "html.parser")

            # Extract emails from text
            text = soup.get_text()
            emails = re.findall(pattern, text)
            all_emails.update(emails)

            # Extract from mailto: links
            for link in soup.find_all("a", href=True):
                href = link["href"]
                if href.startswith("mailto:"):
                    email = href.replace("mailto:", "").split("?")[0]
                    all_emails.add(email)
                else:
                    full_url = urljoin(url, href)
                    if urlparse(full_url).netloc == domain:
                        to_visit.append(full_url)

            print(f"Visited: {url} ({len(emails)} emails)")
        except Exception as e:
            print(f"Error: {url} - {e}")

    return sorted(all_emails)

emails = crawl_and_extract("https://example.com")
print(f"\nTotal unique emails: {len(emails)}")
for email in emails:
    print(email)

Legal and Ethical Considerations

Before extracting email addresses from websites, consider these important points:

• Check robots.txt: Many websites specify crawling rules in their robots.txt file. Respect these directives, especially for automated scraping.
• Rate limiting: If crawling multiple pages, add delays between requests (e.g., 1–2 seconds) to avoid overloading the server.
• GDPR compliance: Under the GDPR, the fact that an email address is publicly visible does not automatically give you the right to use it for marketing. You still need a lawful basis for processing. See our GDPR guide for details.
• Terms of service: Many websites prohibit automated scraping in their terms of service. Review these before crawling.
• Distinguish extraction from harvesting: Extracting emails from a website you own or have permission to access is different from mass-harvesting emails across the internet. The latter is prohibited in many jurisdictions.

Tips for Best Results

• Check the HTML source. Many email addresses are hidden behind buttons or forms. Viewing the page source (Ctrl+U) often reveals addresses not visible on the rendered page.
• Look for obfuscated emails. Some websites protect email addresses using JavaScript encoding, HTML entities, or formats like “name [at] domain [dot] com”. These require additional processing beyond standard regex.
• Focus on relevant pages. Contact, about, team, and impressum pages are the most likely to contain email addresses. Start there before crawling the entire site.
• Validate your results. Not every string matching an email pattern is a real address. Filter out obvious placeholders like example@example.com or noreply@domain.com.
• Remove duplicates. Large websites often repeat the same email address on multiple pages. All methods above include deduplication.
• Use our tool for quick results. If you just need emails from a handful of pages, copy-pasting text or HTML source into our tool is faster than writing a script.

Method 4: Using Browser Developer Tools

Your browser’s built-in developer tools offer a fast, no-install way to extract email addresses from any web page — including pages that load content dynamically via JavaScript.

Inspect the Network Tab

1. Open the page in Chrome or Firefox and press F12 to open DevTools.
2. Go to the Network tab and reload the page (Ctrl+R).
3. Filter requests by XHR / Fetch to see API calls. Contact data — including email addresses — is often returned in these JSON responses rather than in the initial HTML.
4. Click any suspicious request and inspect the Response tab. Use Ctrl+F to search for the @ character.

Search the Full Page Source

Press Ctrl+U (View Page Source) to open the raw HTML in a new tab, then use Ctrl+F and search for @ or mailto. This finds addresses buried in script blocks, hidden inputs, and HTML comments that don’t appear on the rendered page.

For a faster workflow, copy the entire page source and paste it into our email extractor — it scans the full HTML instantly and returns a clean, deduplicated list.

Handling JavaScript-Rendered Pages

Single-page apps (React, Vue, Angular) and infinite-scroll feeds assemble their HTML in the browser rather than serving it from the server. A simple HTTP request to the URL returns an almost-empty HTML shell — the email addresses are only present after JavaScript executes.

Two common solutions:

• Headless browsers (Puppeteer / Playwright): These tools control a real Chromium instance programmatically, wait for the page to fully render, and then let you read the complete DOM. A Puppeteer snippet to grab rendered HTML looks like this:

const puppeteer = require('puppeteer');
const { execSync } = require('child_process');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com/team', { waitUntil: 'networkidle2' });
  const html = await page.content();
  const emails = [...html.matchAll(/[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/g)]
    .map(m => m[0]);
  console.log([...new Set(emails)].join('\n'));
  await browser.close();
})();

• Selenium (Python/Java): An older but widely supported alternative that works with Chrome, Firefox, and Edge via WebDriver.

For occasional lookups, the DevTools approach is quicker. For recurring scraping of JS-heavy sites, a headless browser script is the reliable choice.

Frequently Asked Questions

Can I extract emails from a website I don’t own?

Technically yes, if the addresses are publicly visible. Legally, it depends on the site’s terms of service, your jurisdiction, and your intended use. Always check the ToS and ensure you have a lawful basis before using extracted addresses for marketing.

What is the fastest method for a single page?

View the page source (Ctrl+U), copy it all, and paste it into our tool. Results appear in under a second.

My Python script finds no emails, but I can see them on the page.

The page is almost certainly JavaScript-rendered. The requests library only fetches the HTML skeleton; it does not execute JavaScript. Switch to Puppeteer, Playwright, or Selenium to get the fully rendered DOM.

How do I avoid getting blocked while crawling?

Rotate user-agent strings, add 1–3 second delays between requests, respect robots.txt disallow rules, and avoid crawling the same domain from multiple threads simultaneously.

FAQ

How do I extract emails from a website?

Fetch one public URL or paste its page text. With “Scan contact pages”, the extractor checks up to 20 public contact, imprint, team and legal pages on the same website after you allow the request, then shows source pages for the addresses found.

Why does URL fetching miss some addresses?

Some sites block external requests or load addresses only through JavaScript. Text inside images is not read; possible email graphics trigger a review warning. In those cases, copy the visible page text and paste it into the extractor.

Am I allowed to collect addresses from other people’s websites?

Reading publicly published contact data is one thing — sending is another: unsolicited marketing to collected addresses violates GDPR principles and anti-spam laws. See our GDPR guide to email extraction for details.