Python ile Web Scraping Rehberi 2026

Python ile Web Scraping'e Giriş

Web scraping, internet üzerindeki web sayfalarından yapılandırılmış veri çıkarma işlemidir. 2026 yılında veri odaklı karar alma süreçlerinin önem kazanmasıyla birlikte, web scraping her zamankinden daha kritik bir beceri haline gelmiştir. E-ticaret fiyat takibinden pazar araştırmasına, akademik çalışmalardan rekabet analizine kadar pek çok alanda kullanılan bu teknik, doğru araçlarla son derece verimli bir şekilde uygulanabilir.

Python, zengin kütüphane ekosistemi, okunabilir söz dizimi ve güçlü topluluk desteği sayesinde web scraping için en çok tercih edilen programlama dilidir. Bu rehberde, Python'un sunduğu tüm scraping araçlarını derinlemesine inceleyecek, gerçek dünya örnekleriyle proxy entegrasyonunu, rate limiting yönetimini ve anti-bot sistemlerini aşma tekniklerini ele alacağız. İster yeni başlayan ister deneyimli bir geliştirici olun, bu kapsamlı rehber sizin için değerli bilgiler içermektedir.

Web scraping proxy kullanımı, profesyonel veri toplama projelerinin vazgeçilmez bir parçasıdır. Doğru proxy altyapısı olmadan büyük ölçekli scraping projeleri sürdürülebilir olmaktan çıkar. Bu rehberde proxy entegrasyonuna özel bir bölüm ayırdık.

Web Scraping İçin Python Ortamını Hazırlama

Başlamadan önce, Python ortamınızı doğru bir şekilde yapılandırmanız gerekir. Sanal ortam (virtual environment) kullanmak, proje bağımlılıklarını izole etmek açısından en iyi uygulamadır. Bu sayede farklı projeleriniz arasındaki kütüphane çakışmalarını önleyebilirsiniz.

Gerekli Kütüphanelerin Kurulumu

Aşağıdaki komutlarla sanal ortamınızı oluşturun ve gerekli kütüphaneleri yükleyin:

# Sanal ortam oluşturma
python -m venv scraping-env
source scraping-env/bin/activate  # Linux/Mac
# scraping-envScriptsactivate   # Windows

# Temel kütüphaneleri yükleme
pip install requests beautifulsoup4 lxml
pip install scrapy playwright selenium
pip install fake-useragent aiohttp

# Playwright tarayıcılarını indirme
playwright install chromium

Bu kütüphanelerin her biri farklı scraping senaryoları için optimize edilmiştir. requests basit HTTP istekleri için, BeautifulSoup HTML parsing için, Scrapy büyük ölçekli projeler için, Playwright ve Selenium ise JavaScript ile render edilen dinamik sayfalar için idealdir.

Requests Kütüphanesi ile HTTP İstekleri

Python'un requests kütüphanesi, web scraping'in temel yapı taşıdır. Basit ve sezgisel API'si sayesinde HTTP istekleri göndermek son derece kolaydır. GET ve POST istekleri, özel başlıklar (headers), çerez yönetimi ve oturum (session) desteği gibi özellikleri barındırır.

Temel GET İsteği

import requests

url = "https://example.com/products"
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "Accept-Language": "tr-TR,tr;q=0.9,en-US;q=0.8",
    "Accept": "text/html,application/xhtml+xml"
}

response = requests.get(url, headers=headers, timeout=30)

if response.status_code == 200:
    html_content = response.text
    print(f"Sayfa boyutu: {len(html_content)} karakter")
else:
    print(f"Hata kodu: {response.status_code}")

Başlık (header) bilgilerini doğru ayarlamak, sunucunun isteğinizi gerçek bir tarayıcıdan geliyormuş gibi algılamasını sağlar. User-Agent başlığı bu konuda en kritik parametredir. Farklı User-Agent değerleri kullanarak isteklerinizi daha doğal gösterebilirsiniz.

Session Kullanımı ve Çerez Yönetimi

import requests

session = requests.Session()
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
    "Accept-Language": "tr-TR,tr;q=0.9"
})

# Giriş yapma
login_data = {"username": "user", "password": "pass"}
session.post("https://example.com/login", data=login_data)

# Oturum açık kalarak istek gönderme
response = session.get("https://example.com/dashboard")
print(response.text)

Session nesnesi, çerezleri ve başlıkları otomatik olarak takip eder. Bu özellik, giriş yapılması gereken sitelerde veri toplarken son derece faydalıdır.

BeautifulSoup ile HTML Parsing

BeautifulSoup, HTML ve XML belgelerini ayrıştırmak (parse etmek) için kullanılan güçlü bir Python kütüphanesidir. CSS seçicileri ve DOM gezinme yöntemleri sayesinde, sayfa içeriğinden istediğiniz verileri kolayca çıkarabilirsiniz. Öğrenme eğrisi düşüktür ve küçük-orta ölçekli projeler için idealdir.

Temel Kullanım ve Element Bulma

from bs4 import BeautifulSoup
import requests

url = "https://example.com/products"
response = requests.get(url)
soup = BeautifulSoup(response.text, "lxml")

# CSS seçici ile ürünleri bulma
products = soup.select("div.product-card")

for product in products:
    title = product.select_one("h3.product-title").get_text(strip=True)
    price = product.select_one("span.price").get_text(strip=True)
    link = product.select_one("a")["href"]
    print(f"Ürün: {title} | Fiyat: {price} | Link: {link}")

# Tüm bağlantıları çıkarma
all_links = soup.find_all("a", href=True)
for link in all_links:
    print(link["href"])

BeautifulSoup'un select() metodu CSS seçicilerini, find() ve find_all() metotları ise etiket adı, sınıf ve öznitelik filtrelerini destekler. Karmaşık HTML yapılarından veri çekmek için bu yöntemleri birlikte kullanabilirsiniz.

Sayfalama (Pagination) ile Çoklu Sayfa Scraping

from bs4 import BeautifulSoup
import requests
import time

base_url = "https://example.com/products?page={}"
all_products = []

for page in range(1, 51):
    response = requests.get(base_url.format(page))
    soup = BeautifulSoup(response.text, "lxml")

    products = soup.select("div.product-card")
    if not products:
        break

    for product in products:
        title = product.select_one("h3").get_text(strip=True)
        all_products.append(title)

    print(f"Sayfa {page}: {len(products)} ürün bulundu")
    time.sleep(2)  # Rate limiting

print(f"Toplam {len(all_products)} ürün toplandı")

Scrapy ile Gelişmiş Web Scraping

Scrapy, Python ekosistemindeki en kapsamlı web scraping framework'üdür. Asenkron istek yönetimi, otomatik rate limiting, yerleşik veri pipeline'ları ve middleware desteği sayesinde büyük ölçekli projeler için biçilmiş kaftandır. Scrapy, aynı anda yüzlerce isteği eş zamanlı olarak işleyebilir ve toplanan verileri JSON, CSV veya veritabanına otomatik olarak kaydedebilir.

import scrapy

class ProductSpider(scrapy.Spider):
    name = "products"
    start_urls = ["https://example.com/products"]

    custom_settings = {
        "DOWNLOAD_DELAY": 2,
        "CONCURRENT_REQUESTS": 8,
        "RETRY_TIMES": 3,
        "USER_AGENT": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
    }

    def parse(self, response):
        for product in response.css("div.product-card"):
            yield {
                "title": product.css("h3::text").get(),
                "price": product.css("span.price::text").get(),
                "url": response.urljoin(product.css("a::attr(href)").get()),
            }

        next_page = response.css("a.next-page::attr(href)").get()
        if next_page:
            yield response.follow(next_page, self.parse)

Scrapy'nin en büyük avantajlarından biri, middleware sistemidir. Proxy rotasyonu, User-Agent değiştirme ve hata yönetimi gibi işlemleri middleware katmanında merkezi olarak yönetebilirsiniz. Bu sayede spider kodunuz temiz ve odaklı kalır.

Playwright ile Dinamik Sayfa Scraping

Modern web uygulamaları, içeriklerini JavaScript ile dinamik olarak yükler. React, Vue.js veya Angular gibi frameworklerle geliştirilen tek sayfa uygulamalarında (SPA), sayfa kaynağı (page source) genellikle boş bir HTML iskeleti içerir. Bu tür siteleri scrape etmek için tarayıcı otomasyonu araçlarına ihtiyaç duyarsınız. Playwright, Microsoft tarafından geliştirilen modern bir tarayıcı otomasyon kütüphanesidir ve Chromium, Firefox ve WebKit tarayıcılarını destekler.

import asyncio
from playwright.async_api import async_playwright

async def scrape_dynamic_page():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()

        await page.goto("https://example.com/products", wait_until="networkidle")
        await page.wait_for_selector("div.product-card", timeout=10000)

        products = await page.query_selector_all("div.product-card")
        for product in products:
            title = await product.query_selector("h3")
            title_text = await title.inner_text()
            print(f"Ürün: {title_text}")

        await browser.close()

asyncio.run(scrape_dynamic_page())

Playwright, sonsuz kaydırma (infinite scroll), tıklama ile yüklenen içerikler ve AJAX istekleri gibi dinamik davranışları simüle etmek için güçlü araçlar sunar. wait_for_selector ve wait_until parametreleri sayesinde, içeriğin tam olarak yüklenmesini bekleyebilirsiniz.

Proxy Entegrasyonu: Güvenilir Scraping'in Anahtarı

Büyük ölçekli web scraping projelerinde proxy kullanımı bir tercih değil, zorunluluktur. IP adresiniz engellendiğinde tüm projeniz durur. Rotating proxy hizmetleri, her istekte farklı bir IP adresi kullanarak bu riski ortadan kaldırır. Residential proxy çözümleri ise gerçek kullanıcı IP'leri kullanarak en düşük engellenme oranını sunar.

Requests ile Proxy Kullanımı

import requests

proxies = {
    "http": "http://kullanici:[email protected]:8080",
    "https": "http://kullanici:[email protected]:8080"
}

response = requests.get(
    "https://example.com",
    proxies=proxies,
    timeout=30
)
print(response.status_code)

Scrapy ile Proxy Middleware

# settings.py
DOWNLOADER_MIDDLEWARES = {
    "scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware": 110,
    "myproject.middlewares.ProxyMiddleware": 100,
}

# middlewares.py
import random

class ProxyMiddleware:
    def __init__(self):
        self.proxies = [
            "http://kullanici:[email protected]:8080",
            "http://kullanici:[email protected]:8080",
            "http://kullanici:[email protected]:8080",
        ]

    def process_request(self, request, spider):
        request.meta["proxy"] = random.choice(self.proxies)

Playwright ile Proxy Kullanımı

from playwright.async_api import async_playwright
import asyncio

async def scrape_with_proxy():
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={
                "server": "http://proxy.proxyturk.com:8080",
                "username": "kullanici",
                "password": "sifre"
            }
        )
        page = await browser.new_page()
        await page.goto("https://example.com")
        content = await page.content()
        await browser.close()
        return content

asyncio.run(scrape_with_proxy())

Proxy seçiminde proje gereksinimlerinizi göz önünde bulundurun. Yüksek anonimlik gerektiren projeler için residential proxy, hız öncelikli projeler için datacenter proxy, sosyal medya ve mobil uygulama verileri için mobil proxy tercih edebilirsiniz. SOCKS5 proxy protokolü ise tüm trafik türlerini desteklemesi nedeniyle esneklik sağlar. IPv4 proxy çözümleri geniş uyumluluk sunarken, IPv6 proxy seçenekleri daha düşük maliyetle yüksek performans elde etmenizi sağlar.

Rate Limiting ve İstek Yönetimi

Hedef siteye aşırı yük bindirmemek hem etik bir gereklilik hem de engellenme riskini azaltan pratik bir stratejidir. Rate limiting, istekleriniz arasında kontrollü gecikmeler ekleyerek sunucuyu bunaltmadan veri toplamanızı sağlar.

import time
import random
import requests
from concurrent.futures import ThreadPoolExecutor, as_completed

def fetch_url(url, session):
    delay = random.uniform(1.5, 4.0)
    time.sleep(delay)
    try:
        response = session.get(url, timeout=30)
        return {"url": url, "status": response.status_code, "size": len(response.text)}
    except requests.RequestException as e:
        return {"url": url, "error": str(e)}

urls = [f"https://example.com/page/{i}" for i in range(1, 101)]
session = requests.Session()
session.headers.update({"User-Agent": "Mozilla/5.0"})

with ThreadPoolExecutor(max_workers=3) as executor:
    futures = {executor.submit(fetch_url, url, session): url for url in urls}
    for future in as_completed(futures):
        result = future.result()
        print(result)

Eş zamanlı istek sayısını (concurrent requests) sınırlandırmak ve her istek arasına rastgele gecikmeler eklemek, hem sunucu yükünü azaltır hem de bot algılama sistemlerini tetikleme olasılığını düşürür. Scrapy'de bu ayarları DOWNLOAD_DELAY ve CONCURRENT_REQUESTS parametreleriyle kolayca yapılandırabilirsiniz.

Anti-Bot Sistemlerini Anlama ve Aşma

Modern web siteleri, Cloudflare, DataDome, PerimeterX ve Akamai gibi gelişmiş anti-bot çözümlerini kullanmaktadır. Bu sistemler; IP adresini, tarayıcı parmak izini (browser fingerprint), istek kalıplarını, JavaScript çalıştırma yeteneğini ve fare hareketlerini analiz ederek bot trafiğini tespit etmeye çalışır.

Anti-bot sistemlerini aşmak için aşağıdaki stratejileri uygulayabilirsiniz:

• User-Agent Rotasyonu: Her istekte farklı tarayıcı kimliği kullanarak parmak izi çeşitliliği sağlayın. fake-useragent kütüphanesi bu konuda yardımcı olur.
• Başlık Çeşitliliği: Accept, Accept-Language, Accept-Encoding gibi HTTP başlıklarını gerçek tarayıcı davranışlarına uygun şekilde ayarlayın.
• IP Rotasyonu: Rotating proxy kullanarak her istekte veya belirli aralıklarla IP adresini değiştirin. Residential IP'ler, datacenter IP'lerine kıyasla çok daha düşük engellenme oranına sahiptir.
• JavaScript Rendering: Playwright veya Selenium gibi gerçek tarayıcı motorları kullanarak JavaScript zorluklarını (challenge) aşın.
• İstek Zamanlaması: İsteklerinizi insan davranışlarını taklit edecek şekilde rastgele aralıklarla gönderin. Sabit gecikme yerine rastgele gecikme tercih edin.
• Oturum Yönetimi: Çerezleri ve oturumları doğru şekilde yöneterek, süreklilik gösteren bir tarayıcı davranışı sergileyin.

from fake_useragent import UserAgent
import requests
import random

ua = UserAgent()

def get_random_headers():
    return {
        "User-Agent": ua.random,
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9",
        "Accept-Language": random.choice(["tr-TR,tr;q=0.9", "en-US,en;q=0.9"]),
        "Accept-Encoding": "gzip, deflate, br",
        "Connection": "keep-alive",
        "Cache-Control": "max-age=0",
    }

response = requests.get("https://example.com", headers=get_random_headers())

Etik Web Scraping ve robots.txt Uyumu

Web scraping yaparken etik ve yasal kurallara uyum sağlamak, uzun vadeli başarı için hayati öneme sahiptir. robots.txt dosyası, web sitesi sahiplerinin hangi sayfaların taranabilir olduğunu belirledikleri standart bir protokoldür. Bu dosyaya uymak hem etik bir sorumluluk hem de yasal açıdan koruyucu bir önlemdir.

from urllib.robotparser import RobotFileParser

rp = RobotFileParser()
rp.set_url("https://example.com/robots.txt")
rp.read()

url_to_scrape = "https://example.com/products"

if rp.can_fetch("*", url_to_scrape):
    print("Bu sayfa scrape edilebilir")
else:
    print("Bu sayfa robots.txt tarafından engelleniyor")

Etik scraping prensipleri şunları kapsar: robots.txt kurallarına uyum, makul istek hızı kullanımı, kişisel verilerin toplanmaması, hedef siteye aşırı yük bindirilmemesi ve telif hakkıyla korunan içeriklerin izinsiz kopyalanmaması. Bu kurallara uyarak hem yasal sorunlardan kaçınır hem de web ekosisteminin sağlığına katkıda bulunursunuz.

Verileri Kaydetme ve İşleme

Topladığınız verileri yapılandırılmış bir formatta kaydetmek, analiz sürecinizi kolaylaştırır. CSV, JSON ve veritabanı gibi farklı depolama yöntemlerini projenizin gereksinimlerine göre seçebilirsiniz.

import json
import csv

# JSON olarak kaydetme
data = [{"title": "Ürün 1", "price": "99.90"}, {"title": "Ürün 2", "price": "149.90"}]
with open("products.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# CSV olarak kaydetme
with open("products.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "price"])
    writer.writeheader()
    writer.writerows(data)

Sonuç ve Öneriler

Python ile web scraping, doğru araçlar ve stratejilerle son derece güçlü bir veri toplama yöntemidir. Bu rehberde ele aldığımız konuları özetlemek gerekirse: requests ile basit istekler, BeautifulSoup ile HTML parsing, Scrapy ile büyük ölçekli scraping, Playwright ile dinamik sayfa desteği, proxy entegrasyonu ve anti-bot aşma teknikleri.

Başarılı bir web scraping projesi için şu adımları izleyin:

1. Hedef sitenin yapısını analiz edin ve uygun aracı seçin.
2. robots.txt dosyasını kontrol ederek izin verilen sayfaları belirleyin.
3. Güvenilir bir proxy altyapısı kurun — residential proxy en düşük engellenme oranını sunar.
4. Rate limiting stratejinizi belirleyin ve anti-bot önlemlerinizi yapılandırın.
5. Verileri yapılandırılmış bir formatta kaydedin ve düzenli olarak doğrulayın.

Profesyonel web scraping projeleri için kaliteli proxy hizmetine ihtiyacınız varsa, proxy satın al sayfamızdan ihtiyacınıza uygun çözümü keşfedebilirsiniz. Web scraping proxy paketlerimiz, yüksek başarı oranı ve düşük gecikme süreleriyle projelerinizi hızlandırır.