Facebook Page Scraper: Actually Got It Working Without Login

import requests
from bs4 import BeautifulSoup
import time
import random
from typing import List, Dict
import json

class FacebookScraper:
    def __init__(self, cookies_file: str = 'fb_cookies.json'):
        """
        Initialize with a pool of cookies from different accounts
        Cookies should be exported from a real browser session
        """
        self.cookies_pool = self._load_cookies(cookies_file)
        self.current_cookie_index = 0
        self.session = requests.Session()

        # Rotate user agents to avoid fingerprinting
        self.user_agents = [
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
        ]

    def _load_cookies(self, cookies_file: str) -> List[Dict]:
        """Load cookies from JSON file"""
        try:
            with open(cookies_file, 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            print(f"Cookies file {cookies_file} not found")
            return []

    def _get_current_cookies(self) -> Dict:
        """Get current cookies from pool and rotate"""
        if not self.cookies_pool:
            return {}

        cookies = self.cookies_pool[self.current_cookie_index]
        self.current_cookie_index = (self.current_cookie_index + 1) % len(self.cookies_pool)
        return cookies

    def _make_headers(self) -> Dict:
        """Generate realistic headers"""
        return {
            'User-Agent': random.choice(self.user_agents),
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
            'Accept-Language': 'en-US,en;q=0.9',
            'Accept-Encoding': 'gzip, deflate, br',
            'DNT': '1',
            'Connection': 'keep-alive',
            'Upgrade-Insecure-Requests': '1'
        }

    def scrape_page(self, page_id: str, max_posts: int = 50) -> List[Dict]:
        """
        Scrape posts from a Facebook page

        Args:
            page_id: Facebook page ID or username
            max_posts: Maximum number of posts to scrape

        Returns:
            List of post dictionaries
        """
        url = f"https://mbasic.facebook.com/{page_id}"
        posts = []

        cookies = self._get_current_cookies()
        if not cookies:
            print("No cookies available, scraping may fail")
            cookies = {}

        try:
            # Use mbasic.facebook.com for simpler HTML
            response = self.session.get(
                url,
                headers=self._make_headers(),
                cookies=cookies,
                timeout=15
            )

            if response.status_code == 200:
                soup = BeautifulSoup(response.content, 'html.parser')

                # mbasic structure - simpler than desktop
                post_elements = soup.find_all('div', class_='async_like')

                for post_elem in post_elements[:max_posts]:
                    try:
                        post_data = self._extract_post_data(post_elem)
                        if post_data:
                            posts.append(post_data)
                    except Exception as e:
                        print(f"Error extracting post: {e}")
                        continue

                # Random delay to mimic human behavior
                time.sleep(random.uniform(2, 5))

            elif response.status_code == 403 or 'login' in response.url:
                print(f"Access denied for page {page_id}, may need fresh cookies")

        except Exception as e:
            print(f"Error scraping page {page_id}: {e}")

        return posts

    def _extract_post_data(self, post_elem) -> Dict:
        """Extract data from post element"""
        # Implementation depends on HTML structure
        return {
            'text': post_elem.get_text(strip=True),
            'timestamp': self._extract_timestamp(post_elem)
        }

    def _extract_timestamp(self, post_elem) -> str:
        """Extract timestamp from post"""
        # Parse timestamp from element
        return ""

# Cookie rotation strategy
import json
import random
from datetime import datetime, timedelta

class CookieManager:
    def __init__(self):
        self.cookies_file = 'fb_cookies.json'
        self.usage_log = {}

    def get_fresh_cookie(self) -> Dict:
        """
        Get a cookie that hasn't been used recently
        Implements cooling period between uses
        """
        with open(self.cookies_file, 'r') as f:
            cookies = json.load(f)

        # Filter cookies that haven't been used in 2 hours
        now = datetime.now()
        available_cookies = []

        for cookie_set in cookies:
            cookie_id = cookie_set.get('id', 'unknown')

            if cookie_id not in self.usage_log:
                available_cookies.append(cookie_set)
                continue

            last_used = self.usage_log[cookie_id]
            if now - last_used > timedelta(hours=2):
                available_cookies.append(cookie_set)

        if not available_cookies:
            print("All cookies in cooling period, waiting...")
            return None

        # Select random cookie to distribute usage
        selected = random.choice(available_cookies)
        cookie_id = selected.get('id', 'unknown')
        self.usage_log[cookie_id] = now

        return {
            c['name']: c['value']
            for c in selected.get('cookies', [])
        }

# Usage
cookie_manager = CookieManager()

while True:
    cookie = cookie_manager.get_fresh_cookie()
    if cookie:
        # Scrape with this cookie
        scrape_with_cookie(cookie)
    else:
        # Wait before retry
        time.sleep(3600)  # Wait 1 hour

import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
import time
import random

def human_like_scroll(driver):
    """Scroll like a human, not a bot"""
    last_height = driver.execute_script("return document.body.scrollHeight")

    for _ in range(random.randint(3, 5)):
        # Random scroll distance
        scroll_distance = random.randint(300, 800)

        # Smooth scroll (human-like)
        driver.execute_script(f"window.scrollBy(0, {scroll_distance});")

        # Random pause
        time.sleep(random.uniform(0.5, 2.0))

    # Move mouse randomly to simulate human
    actions = ActionChains(driver)
    for _ in range(3):
        x_offset = random.randint(-100, 100)
        y_offset = random.randint(-100, 100)
        actions.move_by_offset(x_offset, y_offset).perform()
        time.sleep(random.uniform(0.1, 0.5))

def scrape_facebook_page(page_url: str):
    """
    Scrape Facebook page with human-like behavior
    """
    options = uc.ChromeOptions()

    # Use realistic user agent
    options.add_argument('--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36')

    driver = uc.Chrome(options=options)

    try:
        driver.get(page_url)

        # Wait for page load
        time.sleep(random.uniform(2, 4))

        # Scroll like a human
        human_like_scroll(driver)

        # Extract content
        posts = driver.find_elements(By.CSS_SELECTOR, '[data-testid="tweet"]')
        # Parse posts...

        # Random "reading" time
        time.sleep(random.uniform(3, 8))

    finally:
        driver.quit()