hi 
English 
Español 
中國人 
Tiếng Việt 
Deutsch 
Українська 
Português 
Français 
Türkçe 
한국인 
Italiano 
Gaeilge 
اردو 
Indonesia 
Polski प्रत्यक्ष आउटरीच के काम करने के लिए, आपको एक ठोस आधार की आवश्यकता होती है – वास्तविक और अद्यतन ईमेल पतों का डेटाबेस। यहीं पर Python के साथ ईमेल स्क्रैपिंग उपयोगी होती है: वेबसाइटों से प्रोग्रामेटिक रूप से पते एकत्र करने का एक तरीका।
इस गाइड में, हम यह देखेंगे कि शुरुआत से ईमेल स्क्रैपिंग को Python के साथ कैसे बनाया जाए, डायनेमिक पेजों को कैसे संभाला जाए, एकत्र किए गए पतों को कैसे फ़िल्टर और सत्यापित किया जाए, और परिणामस्वरूप डेटा को वास्तविक मार्केटिंग या व्यावसायिक वर्कफ़्लो में कैसे उपयोग किया जाए।
यह सामग्री उपयोगी है यदि आपको आवश्यकता है:
आगे हम देखेंगे कि कैसे सार्वजनिक रूप से उपलब्ध पृष्ठों को सीधे संचार चैनल में बदला जा सकता है उन लोगों के साथ जो आपके ग्राहक बन सकते हैं – Python का उपयोग करके।
मूल रूप से, इस प्रकार की स्क्रैपिंग का मतलब है HTML या डायनेमिक पृष्ठों को स्वचालित रूप से स्कैन करना और सामग्री या विशेषताओं में उन पैटर्न की खोज करना जो पते के प्रारूप (उदाहरण के लिए, username@domain.tld) से मेल खाते हैं। फिर आप परिणामों को फ़िल्टर, सत्यापित और सहेजते हैं।
इसका व्यापक रूप से उपयोग व्यवसाय, मार्केटिंग, शोध और नियमित प्रक्रियाओं के स्वचालन में किया जाता है। यह विशेष रूप से उपयोगी है जब आपको कई स्रोतों से बड़ी मात्रा में सार्वजनिक जानकारी एकत्र और संरचित करनी हो।
विशिष्ट कार्यों के उदाहरण जहाँ Python के साथ ईमेल स्क्रैपिंग लागू होती है:
यदि आप ई-कॉमर्स परियोजनाओं के लिए संपर्क डेटा एकत्र करने में रुचि रखते हैं, तो हमारे ईकॉमर्स डेटा स्क्रैपिंग गाइड को देखें।
स्क्रैपिंग को प्रभावी बनाने के लिए, आपको पर्यावरण तैयार करना होगा और सही उपकरण चुनने होंगे। ये आपको डेटा को तेजी से प्राप्त करने, जटिल या डायनेमिक पेजों को संभालने और बड़े प्रोजेक्ट्स को संगठित करने में मदद करते हैं।
स्क्रैपिंग के लिए सामान्य Python उपकरण:
| टूल | उपयोग |
|---|---|
| requests / httpx | स्थिर पृष्ठ प्राप्त करना |
| BeautifulSoup | HTML पार्सिंग / तत्व खोज |
| re (regular expressions) | पैटर्न निकालना |
| lxml | तेज़ पार्सिंग |
| Selenium / Playwright | JavaScript-चालित पृष्ठों को संभालना |
| Scrapy | बड़े क्रॉल के लिए एक पूर्ण-स्तरीय फ़्रेमवर्क |
PHP
Node.js
Python
Java
Golang
pip install requests beautifulsoup4 lxml
pip install selenium # यदि आपको डायनेमिक रेंडरिंग की आवश्यकता हैयह देखने के लिए कि समान विधियाँ अन्य प्लेटफार्मों के लिए कैसे लागू होती हैं, हमारे Python का उपयोग करके Reddit को स्क्रैप करें पर विस्तृत गाइड देखें।
# 1. Create an HTTP session with timeouts and retries
session = make_session()
# 2. Load the page
html = session.get(url)
# 3. Look for email addresses:
# - via regex across the entire text
# - via mailto: links in HTML
emails = extract_emails_from_text(html)
emails.update(find_mailto_links(html))
# 4. Return a unique list of addresses
return emails"""
Iterate over internal links within one domain and collect email addresses.
Highlights:
- Page limit (max_pages) to stop safely
- Verifying that a link belongs to the base domain
- Avoiding re-visits
- Optional respect for robots.txt
"""
from __future__ import annotations
from collections import deque
from typing import Set
from urllib.parse import urljoin, urlparse, urlsplit, urlunsplit
import time
import requests
from bs4 import BeautifulSoup
import lxml # Import lxml to ensure it's available for BeautifulSoup
from urllib import robotparser # standard robots.txt parser
# We use functions from the previous block:
# - make_session()
# - scrape_emails_from_url()
import re
# General regular expression for email addresses
EMAIL_RE = re.compile(r"[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9.-]+")
def scrape_emails_from_url(url: str, session: requests.Session) -> Set[str]:
"""Collect email addresses from the given URL page."""
emails: Set[str] = set()
try:
resp = session.get(url, timeout=getattr(session, "_default_timeout", 10.0))
resp.raise_for_status()
# Regular expression for email addresses
# Note: this regex isn't perfect, but it's sufficient for typical cases
email_pattern = re.compile(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}")
emails.update(email_pattern.findall(resp.text))
except requests.RequestException:
pass
return emails
def make_session() -> requests.Session:
"""Create and return a requests session with basic settings."""
session = requests.Session()
session.headers.update({
"User-Agent": "EmailScraper/1.0",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.9",
# Don't force Accept-Encoding to avoid br issues without brotli
"Connection": "keep-alive",
})
return session
def same_host(url: str, base_netloc: str) -> bool:
"""True if the link belongs to the same host (domain/subdomain)."""
return urlparse(url).netloc == base_netloc
def load_robots(start_url: str, user_agent: str = "EmailScraper") -> robotparser.RobotFileParser:
"""Read robots.txt and return a parser for permission checks."""
base = urlparse(start_url)
robots_url = f"{base.scheme}://{base.netloc}/robots.txt"
rp = robotparser.RobotFileParser()
rp.set_url(robots_url)
try:
rp.read()
except Exception:
pass
rp.useragent = user_agent
return rp
def normalize_url(url: str, base: str | None = None) -> str | None:
try:
abs_url = urljoin(base, url) if base else url
parts = urlsplit(abs_url)
if parts.scheme not in ("http", "https"):
return None
host = parts.hostname
if not host:
return None
host = host.lower()
netloc = host
if parts.port:
netloc = f"{host}:{parts.port}"
parts = parts._replace(fragment="")
return urlunsplit((parts.scheme.lower(), netloc, parts.path or "/", parts.query, ""))
except Exception:
return None
def in_scope(url: str, base_host: str, include_subdomains: bool) -> bool:
try:
host = urlsplit(url).hostname
if not host:
return False
host = host.lower()
base_host = (base_host or "").lower()
if include_subdomains:
return host == base_host or host.endswith("." + base_host)
else:
return host == base_host
except Exception:
return False
def collect_emails_from_site(
start_url: str,
max_pages: int = 100,
delay_sec: float = 0.5,
respect_robots: bool = True,
include_subdomains: bool = True,
) -> Set[str]:
"""
Traverse pages within a domain and return unique email addresses.
- max_pages: hard limit on visited pages.
- delay_sec: polite pause between requests.
- respect_robots: if True — checks access rules.
- include_subdomains: if True — allows subdomains (www, etc.).
"""
session = make_session()
base_host = (urlparse(start_url).netloc or "").lower()
visited: Set[str] = set()
queue: deque[str] = deque()
enqueued: Set[str] = set()
all_emails: Set[str] = set()
start_norm = normalize_url(start_url)
if start_norm:
queue.append(start_norm)
enqueued.add(start_norm)
rp = load_robots(start_url, user_agent="EmailScraper/1.0") if respect_robots else None
while queue and len(visited) < max_pages:
url = queue.popleft()
if url in visited:
continue
# robots.txt check
if respect_robots and rp is not None:
try:
if not rp.can_fetch("EmailScraper/1.0", url):
continue
except Exception:
pass
# One request: used both for emails and links
try:
resp = session.get(url, timeout=10)
resp.raise_for_status()
html_text = resp.text or ""
except requests.RequestException:
continue
visited.add(url)
# Skip non-HTML pages
ctype = resp.headers.get("Content-Type", "")
if ctype and "text/html" not in ctype:
continue
# Collect emails
for m in EMAIL_RE.findall(html_text):
all_emails.add(m.lower())
# Parse links
soup = BeautifulSoup(html_text, "lxml")
# Emails from mailto:
for a in soup.find_all("a", href=True):
href = a["href"].strip()
if href.lower().startswith("mailto:"):
addr_part = href[7:].split("?", 1)[0]
for piece in addr_part.split(","):
email = piece.strip()
if EMAIL_RE.fullmatch(email):
all_emails.add(email.lower())
for a in soup.find_all("a", href=True):
href = a["href"].strip()
if not href or href.startswith(("javascript:", "mailto:", "tel:", "data:")):
continue
next_url = normalize_url(href, base=url)
if not next_url:
continue
if not in_scope(next_url, base_host, include_subdomains):
continue
if next_url not in visited and next_url not in enqueued:
queue.append(next_url)
enqueued.add(next_url)
if delay_sec > 0:
time.sleep(delay_sec)
try:
session.close()
except Exception:
pass
return all_emails
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(
description="An email scraper that traverses pages within a site and prints discovered addresses."
)
parser.add_argument(
"start_url",
help="Starting URL, for example: https://example.com"
)
parser.add_argument(
"--max-pages",
type=int,
default=100,
dest="max_pages",
help="Maximum number of pages to traverse (default: 100)"
)
parser.add_argument(
"--delay",
type=float,
default=0.5,
help="Delay between requests in seconds (default: 0.5)"
)
parser.add_argument(
"--no-robots",
action="store_true",
help="Ignore robots.txt (use carefully)"
)
scope = parser.add_mutually_exclusive_group()
scope.add_argument(
"--include-subdomains",
dest="include_subdomains",
action="store_true",
default=True,
help="Include subdomains (default)"
)
scope.add_argument(
"--exact-host",
dest="include_subdomains",
action="store_false",
help="Restrict traversal to the exact host (no subdomains)"
)
parser.add_argument(
"--output",
type=str,
default=None,
help="Optional: path to a file to save found email addresses (one per line)"
args = parser.parse_args()
emails = collect_emails_from_site(
args.start_url,
max_pages=args.max_pages,
delay_sec=args.delay,
respect_robots=not args.no_robots,
include_subdomains=args.include_subdomains,
)
for e in sorted(emails):
print(e)
print(f"Found {len(emails)} unique emails.")
if args.output:
try:
with open(args.output, "w", encoding="utf-8") as f:
for e in sorted(emails):
f.write(e + "\n")
except Exception as ex:
print(f"Could not write the output file: {ex}")main.py https://example.comजब आप कोई स्क्रिप्ट चलाते हैं, तो चीजें हमेशा सीधी नहीं होतीं: कई साइटें जानबूझकर ईमेल पतों को छिपाती हैं या केवल तब दिखाती हैं जब JavaScript रेंडर हो चुका हो। यहाँ बताया गया है कि कौन सी चीजें बाधा डाल सकती हैं — और उन्हें कैसे संभाला जाए।
1. ऑबफ्युस्केशन
साइटें अक्सर बॉट्स से पते छिपाने के लिए तकनीकें अपनाती हैं:
2. डायनेमिक पेजेज
आधुनिक साइटें अक्सर JavaScript (जैसे fetch, AJAX) के माध्यम से सामग्री लोड करती हैं। एक साधारण requests.get() एक “खाली” HTML शेल लौटा सकता है जिसमें ईमेल सामग्री नहीं होती।
जब आप ऐसी पृष्ठों का सामना करते हैं, तो व्यावहारिक दृष्टिकोण:
ब्राउज़र लॉन्च करें, पृष्ठ को “लोड” होने दें, आवश्यक तत्वों के प्रकट होने की प्रतीक्षा करें, फिर पूरा HTML कैप्चर करें। यह तब काम करता है जब ईमेल JS द्वारा रेंडर के बाद जोड़ा जाता है।
अक्सर पृष्ठ वास्तव में किसी API से डेटा खींचता है। नेटवर्क अनुरोधों (DevTools → Network) की जाँच करें ताकि यह देखें कि कोई ऐसा अनुरोध है जो JSON में ईमेल या संपर्क जानकारी लौटाता है या नहीं। यदि हाँ, तो सीधे API का उपयोग करना बेहतर है।
कभी-कभी पता JavaScript में “एम्बेडेड” होता है (जैसे Base64 स्ट्रिंग या भागों में विभाजित)। आप उस JS की व्याख्या कर सकते हैं, स्ट्रिंग निकाल सकते हैं और पते को डिकोड कर सकते हैं।
इमेज डाउनलोड करें और OCR (Optical Character Recognition) लागू करें, उदाहरण के लिए Tesseract के साथ। यह अधिक संसाधन-गहन है लेकिन कभी-कभी आवश्यक होता है।
कुछ तत्व कुछ सेकंड बाद या विशिष्ट घटनाओं (स्क्रॉल, क्लिक) के बाद दिखाई देते हैं। इसलिए समझदारी यह है कि:
Python के साथ ईमेल स्क्रैपिंग के लिए इस लेख में बताई गई तकनीकों को लागू करके, आप अपनी स्क्रिप्ट्स को वास्तविक परिस्थितियों में विश्वसनीय रूप से काम करने योग्य बना सकते हैं। ध्यान रखें कि डेटा की गुणवत्ता सीधे बाद के अभियानों की प्रभावशीलता को प्रभावित करती है, इसलिए शुरुआत से ही फ़िल्टरिंग, सत्यापन और सुविधाजनक प्रारूप में सहेजना लागू करना उचित है।
टिप्पणियाँ: 0