Scraping Lazy-Loaded Emails with PHP and Selenium

Scraping emails from websites that use lazy loading can be tricky, as the email content is not immediately available in the HTML source but is dynamically loaded via JavaScript after the page initially loads. PHP, being a server-side language, cannot execute JavaScript directly. In this blog, we will explore techniques and tools to effectively scrape lazy-loaded content and extract emails from websites using PHP.

What is Lazy Loading?

Lazy loading is a technique used by websites to defer the loading of certain elements, like images, text, or email addresses, until they are needed. This helps improve page load times and optimize bandwidth usage. However, it also means that traditional web scraping methods using PHP CURL may not capture all content, as the emails are often loaded after the initial page load via JavaScript.

Why Traditional PHP CURL Fails?

When you use PHP CURL to scrape a webpage, it retrieves the HTML source code as it is when the server sends it. If the website uses lazy loading, the HTML returned by CURL won’t contain the dynamically loaded emails, as these emails are loaded via JavaScript after the page is rendered in the browser.

To handle lazy loading, we need additional tools that can execute JavaScript or simulate a browser’s behavior.

Tools for Scraping Lazy-Loaded Content

1. Headless Browsers (e.g., Selenium with ChromeDriver or PhantomJS): These are browsers without a graphical user interface (GUI) that allow you to simulate full browser interactions, including JavaScript execution.
2. Puppeteer: Puppeteer is a Node.js library that provides a high-level API to control Chrome or Chromium over the DevTools Protocol. It’s particularly useful for scraping content loaded via JavaScript.
3. Cheerio with Puppeteer: This combination allows you to scrape and manipulate lazy-loaded content after it has been rendered by the browser.

Step-by-Step Guide: Scraping Lazy-Loaded Emails with PHP and Selenium

Selenium is a popular tool for web scraping that allows you to interact with web pages like a real user. It can handle JavaScript, simulate scrolling, and load lazy-loaded elements.

Step 1: Install Selenium WebDriver

To use Selenium in PHP, you first need to set up the Selenium WebDriver and a headless browser like ChromeDriver. Here’s how you can do it:

• Download ChromeDriver: This is the tool that will allow Selenium to control Chrome in headless mode.
• Install Selenium using Composer:

composer require facebook/webdriver

Step 2: Set Up Selenium in PHP

use Facebook\WebDriver\Remote\RemoteWebDriver;
use Facebook\WebDriver\Remote\DesiredCapabilities;
use Facebook\WebDriver\WebDriverBy;
use Facebook\WebDriver\Chrome\ChromeOptions;

require_once('vendor/autoload.php');

// Set Chrome options for headless mode
$options = new ChromeOptions();
$options->addArguments(['--headless', '--disable-gpu', '--no-sandbox']);

// Initialize the remote WebDriver
$driver = RemoteWebDriver::create('http://localhost:4444', DesiredCapabilities::chrome()->setCapability(ChromeOptions::CAPABILITY, $options));

// Open the target URL
$driver->get("https://example.com");

// Simulate scrolling to the bottom to trigger lazy loading
$driver->executeScript("window.scrollTo(0, document.body.scrollHeight);");
sleep(3); // Wait for lazy-loaded content

// Extract the page source after scrolling
$html = $driver->getPageSource();

// Use regex to find emails
$pattern = '/[a-z0-9_\.\+-]+@[a-z0-9-]+\.[a-z\.]{2,7}/i';
preg_match_all($pattern, $html, $matches);

// Print found emails
foreach ($matches[0] as $email) {
    echo "Found email: $email\n";
}

// Quit the WebDriver
$driver->quit();

Step 3: Understanding the Code

• Headless Mode: We run the Chrome browser in headless mode to scrape the website without opening a graphical interface.
• Scrolling to the Bottom: Many websites load more content as the user scrolls down. By simulating this action, we trigger the loading of additional content.
• Waiting for Content: The sleep() function is used to wait for JavaScript to load the lazy-loaded content.
• Email Extraction: Once the content is loaded, we use a regular expression to find all email addresses.

Other Methods to Scrape Lazy-Loaded Emails

1. Using Puppeteer with PHP

Puppeteer is a powerful tool for handling lazy-loaded content. Although it’s primarily used with Node.js, you can use it alongside PHP for better JavaScript execution.

Example in Node.js:

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com');

  // Scroll to the bottom to trigger lazy loading
  await page.evaluate(() => {
    window.scrollTo(0, document.body.scrollHeight);
  });
  await page.waitForTimeout(3000); // Wait for content to load

  // Get page content and find emails
  const html = await page.content();
  const emails = html.match(/[a-z0-9_\.\+-]+@[a-z0-9-]+\.[a-z\.]{2,7}/gi);
  console.log(emails);

  await browser.close();
})();

You can integrate this Node.js script with PHP by running it as a shell command.

2. Using Guzzle with JavaScript Executed APIs

Some websites load emails using APIs after page load. You can capture the API calls using browser dev tools and replicate these calls with Guzzle in PHP.

$client = new GuzzleHttp\Client();
$response = $client->request('GET', 'https://api.example.com/emails');
$emails = json_decode($response->getBody(), true);

foreach ($emails as $email) {
    echo $email;
}

Best Practices for Lazy Loading Scraping

1. Avoid Overloading Servers: Implement rate limiting and respect the website’s robots.txt file. Use a delay between requests to prevent getting blocked.
2. Use Proxies: To avoid IP bans, use rotating proxies for large-scale scraping tasks.
3. Handle Dynamic Content Gracefully: Websites might load different content based on user behavior or geographic location. Be sure to handle edge cases where lazy-loaded content doesn’t appear as expected.
4. Error Handling and Logging: Implement robust error handling and logging to track failures, especially when scraping pages with complex lazy-loading logic.

Conclusion

Handling lazy-loaded content in PHP email scraping requires using advanced tools like headless browsers (Selenium) or even hybrid approaches with Node.js tools like Puppeteer. By following these techniques, you can extract emails effectively from websites that rely on JavaScript-based dynamic content loading. Remember to follow best practices for scraping to avoid being blocked and ensure efficient extraction.