---
title: "Playwright ve Selenium Farkı: Hangisini Seçmeli?"
description: "Playwright öğeyi kendiliğinden bekler ve proxy'yi context başına alır; Selenium daha çok dili ve gerçek Safari'yi kapsar. Aynı işi iki araçla yazdık."
url: https://proxynet.io/tr/blog/playwright-vs-selenium
date: 2026-09-19
author: "Acar Diveroli"
category: "Karşılaştırma, Web Scraping"
lang: tr
---

# Playwright ve Selenium Farkı: Hangisini Seçmeli?

Yeni bir veri toplama ya da test projesine başlıyorsunuz ve sayfa JavaScript ile oluşturulduğu için gerçek bir tarayıcı gerekiyor. Ekipte yıllardır Selenium yazan biri var, yeni gelen geliştirici Playwright öneriyor. İkisi de tarayıcıyı koddan açıp tıklıyor, ikisi de ücretsiz; seçimi zorlaştıran da bu benzerlik. Türkçe karşılaştırmaların çoğu konuya test gözüyle bakıyor, proxy ve bekleme gibi veri toplamada belirleyici başlıkları atlıyor.

Bu yazıda iki aracı yedi eksende karşılaştırıyoruz: mimari, otomatik bekleme, proxy yönetimi, dil desteği, tarayıcı kurulumu, paralellik ve hata ayıklama. Aynı küçük işi iki araçla yapan kodları Playwright 1.63, Selenium 4.49 ve Chrome 153 ile Windows 11'de çalıştırdık; gördüklerimizi ilgili bölümlerde aktarıyoruz. "Hangisi daha az fark edilir" sorusu bu yazının konusu değil: iki araç da gerçek bir tarayıcı açar, sitenin kurallarına uymak ikisinde de sizin işinizdir.

> **Not: Kısa cevap**
>
> Playwright, tarayıcıyla kalıcı bir bağlantı üzerinden konuşur, öğe hazır olana kadar kendiliğinden bekler ve proxy'yi kullanıcı adı ve parolayla her context için ayrı alır; yeni projelerde daha az kodla sonuç verir. Selenium, W3C WebDriver standardını izler, Ruby dahil daha çok dili ve gerçek Safari'yi destekler, Grid ile makinelere dağılır; çalışan bir Selenium paketiniz ya da Java ve C# ağırlıklı bir ekibiniz varsa onu bırakmak için çoğu zaman neden yoktur. Proxy kimlik doğrulaması Selenium'da standardın parçası değildir, pratik yol IP whitelist'tir.

## Playwright ve Selenium nedir?

Selenium, 2004'ten beri geliştirilen açık kaynaklı bir tarayıcı otomasyon projesidir. Bugün kullanılan parçası Selenium WebDriver'dır: kodunuz bir tarayıcı sürücüsüne komut gönderir, sürücü de tarayıcıyı yönetir. Kurulum için eski [Selenium Proxy Entegrasyonu](/tr/blog/selenium) yazımız duruyor; o yazı Selenium 3 dönemine ait olduğundan sürücü indirme ve kimlik doğrulama adımlarını aşağıdaki güncel bilgiyle okuyun.

Playwright, Microsoft'un 2020'de yayımladığı açık kaynaklı bir tarayıcı otomasyon kütüphanesidir. Chromium, Firefox ve WebKit motorlarını tek API ile yönetir. Kurulumu ve proxy ayarları [Playwright Nedir ve Proxy ile Nasıl Kullanılır?](/tr/blog/playwright-proxy) yazımızda; burada yalnızca Selenium'dan ayrıştığı noktaları ele alıyoruz.

İkisinin de yanıt verdiği ihtiyaç aynıdır: düz bir HTTP isteğiyle gelmeyen, tarayıcıda JavaScript çalışınca oluşan içerik. Sayfanın gerçekten tarayıcı isteyip istemediğini [Statik ve Dinamik Sayfalar: Headless Tarayıcı Gerekir mi?](/tr/blog/static-vs-dynamic-pages) yazısındaki kontrolle anlarsınız. Veri sayfa kaynağında duruyorsa iki aracın da yerine düz bir HTTP istemcisi ya da [Scrapy](/tr/blog/scrapy-proxy) daha ucuzdur.

## Mimari farkı nedir: WebDriver, BiDi ve CDP

İki aracın neredeyse bütün davranış farkı, tarayıcıyla nasıl konuştuklarından doğar.

Selenium'da bir komutun yolu şöyledir:

1. Kodunuz `driver.find_element(...)` çağrısını yapar.
2. Selenium kütüphanesi bunu W3C WebDriver standardındaki bir HTTP isteğine çevirir.
3. İstek, tarayıcı üreticisinin yazdığı sürücü programına gider: Chrome için ChromeDriver, Firefox için GeckoDriver.
4. Sürücü komutu tarayıcıya uygular, sonucu HTTP yanıtı olarak geri yollar.

Her komut ayrı bir istek ve yanıttır; tarayıcı kendi başına size bir şey bildiremez. Konsola düşen bir hata ya da arka planda giden bir ağ isteği, siz sormadıkça görünmez. Bu eksikliği kapatmak için Selenium projesi tarayıcı üreticileriyle birlikte [WebDriver BiDi](https://www.w3.org/TR/webdriver-bidi/) standardını yazıyor: WebSocket üzerinden çift yönlü bir protokol. Selenium 4'te `options.enable_bidi = True` ile açılıyor; geçiş sürdüğü için bugün Selenium'da iki dünya yan yana yaşıyor.

Playwright'ta yol farklıdır:

1. Kodunuz `page.locator(...).click()` çağrısını yapar.
2. Python, Java ya da .NET kütüphanesi bu çağrıyı pakete gömülü Playwright sürücüsüne iletir. Sürücü bir Node.js sürecidir; sanal ortamda `playwright/driver/node.exe` olarak durur.
3. Sürücü tarayıcıyla kalıcı bir bağlantı üzerinden konuşur. Chromium'da bu, Chrome DevTools Protocol'dür (CDP). Firefox ve WebKit'te Playwright kendi yamalı tarayıcı derlemelerini kullanır.
4. Bağlantı çift yönlü olduğu için tarayıcıdaki olaylar (istek, yanıt, konsol mesajı, indirme) sormanıza gerek kalmadan kodunuza akar.

Bu tercihin bedeli de var. Playwright'ın [tarayıcı belgesi](https://playwright.dev/python/docs/browsers) açıkça söyler: yamalara dayandığı için markalı Firefox ve Safari ile çalışmaz. Chrome ve Edge'i `channel` seçeneğiyle kullanabilirsiniz, ama "gerçek Safari'de test" ihtiyacını WebKit derlemesi karşılamaz; Selenium, Apple'ın kendi sürücüsüyle kurulu Safari'yi yönetir.

## Karşılaştırma tablosu

| | Playwright | Selenium |
|---|---|---|
| Protokol | Kalıcı bağlantı; Chromium'da CDP, Firefox ve WebKit'te yamalı derlemeler | W3C WebDriver (HTTP), yanında gelişmekte olan WebDriver BiDi (WebSocket) |
| Ara katman | Pakete gömülü Playwright sürücüsü | Tarayıcı üreticisinin sürücüsü (ChromeDriver, GeckoDriver) |
| Tarayıcılar | Chromium, Firefox, WebKit; `channel` ile Chrome ve Edge | Chrome, Edge, Firefox, Safari |
| Resmî diller | JavaScript ve TypeScript, Python, Java, .NET | Java, Python, C#, Ruby, JavaScript |
| Bekleme | Eylemlerden önce kendiliğinden | Siz yazarsınız: `WebDriverWait` |
| Proxy kapsamı | Tarayıcı ya da context başına | Tarayıcı oturumu başına |
| Proxy kullanıcı adı ve parola | `proxy` nesnesinde ayrı alanlar | Standartta alan yok; pratik yol IP whitelist |
| Ağ isteğini dinleme ve engelleme | Yerleşik (`route`, `expect_response`) | BiDi ile geliyor; klasik WebDriver'da yok |
| Tarayıcı kurulumu | `playwright install`, sürüme sabitlenmiş derlemeler | Selenium Manager sürücüyü kendisi indirir, kurulu tarayıcıyı kullanır |
| Paralellik | Tek tarayıcıda çok context | Görev başına tarayıcı; makineler arası Selenium Grid |
| Hata ayıklama | Trace Viewer, Inspector, codegen | Ekran görüntüsü, tarayıcı günlüğü, Selenium IDE |

## Aynı iş iki araçla nasıl yazılır?

Deneme sayfamız `quotes.toscrape.com/js-delayed/`: alıntıları JavaScript ile ve on saniye gecikmeyle basan bir alıştırma sitesi. İş şu: sayfayı proxy üzerinden aç, alıntıları oku, "Next" bağlantısına tıkla, ikinci sayfayı doğrula.

Playwright ile:

```python
from playwright.sync_api import sync_playwright

URL = "https://quotes.toscrape.com/js-delayed/"
PROXY = {
    "server": "http://pr.proxynet.io:8000",
    "username": "user",
    "password": "pass",
}

with sync_playwright() as p:
    browser = p.chromium.launch(proxy=PROXY)
    page = browser.new_page()
    page.goto(URL)
    quotes = page.locator("div.quote")
    print("immediately:", quotes.count())  # 0: count() beklemez
    quotes.first.wait_for()  # ilk alıntı sayfaya basılana kadar bekler
    for quote in quotes.all():
        text = quote.locator("span.text").inner_text()
        author = quote.locator("small.author").inner_text()
        print(author, "-", text[:50])
    page.get_by_role("link", name="Next").click()  # tıklamadan önce kendiliğinden bekler
    page.wait_for_url("**/page/2/")
    print(page.url)
    browser.close()
```

Selenium ile:

```python
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait

URL = "https://quotes.toscrape.com/js-delayed/"

options = webdriver.ChromeOptions()
options.add_argument("--headless=new")
# Kullanıcı adı ve parola yok: çıkış IP'niz panelde IP whitelist'e eklenmiş olmalı
options.add_argument("--proxy-server=http://pr.proxynet.io:8000")

driver = webdriver.Chrome(options=options)  # sürücüyü Selenium Manager bulur
try:
    driver.get(URL)
    print("immediately:", len(driver.find_elements(By.CSS_SELECTOR, "div.quote")))  # 0
    wait = WebDriverWait(driver, 15)
    quotes = wait.until(EC.presence_of_all_elements_located((By.CSS_SELECTOR, "div.quote")))
    for quote in quotes:
        text = quote.find_element(By.CSS_SELECTOR, "span.text").text
        author = quote.find_element(By.CSS_SELECTOR, "small.author").text
        print(author, "-", text[:50])
    wait.until(EC.element_to_be_clickable((By.PARTIAL_LINK_TEXT, "Next"))).click()
    wait.until(EC.url_contains("/page/2/"))
    print(driver.current_url)
finally:
    driver.quit()
```

İki betik de yerel test proxy'lerimiz üzerinden aynı on alıntıyı bastı ve `/js-delayed/page/2/` adresine geçti. Satır sayısı birbirine yakın; fark ayrıntıda. Playwright'ta proxy kimliği kodun içinde, Selenium'da yok; tıklama Playwright'ta tek satır, Selenium'da tıklanabilirlik koşulu elle yazılıyor. İki betikte de "immediately" satırı `0` verdi: sayfa yüklenmiş sayılıyor ama içerik henüz yok. Bu, bir sonraki bölümün konusu.

## Otomatik bekleme ile WebDriverWait arasındaki fark nedir?

Dinamik sayfalarda hataların çoğu zamanlamadan çıkar: kod öğeyi arar, JavaScript onu henüz basmamıştır. Selenium'un [bekleme belgesi](https://www.selenium.dev/documentation/webdriver/waits/) bunu yarış durumu diye adlandırır; bazen tarayıcı önce hazır olur ve kod çalışır, bazen kod önce davranır ve hata alırsınız.

Selenium'da çözüm sizin elinizdedir. `driver.get()` sayfanın `load` olayını bekler, ama sonradan JavaScript ile eklenen içeriği bilmez. Örtük beklemenin (implicit wait) varsayılan değeri sıfırdır; öğe yoksa hata hemen döner. Önerilen yol açık beklemedir: `WebDriverWait` bir koşul doğru olana kadar sayfayı yoklar. Belge bir uyarı daha yapar: ikisini birlikte kullanmayın, süreler öngörülemez hale gelir.

Playwright aynı işi eylemin içine gömer. [Actionability belgesine](https://playwright.dev/python/docs/actionability) göre `click()` çağrısı öğe görünür, konumu sabit, tıklamayı alabilir ve etkin olana kadar bekler; koşullar süre içinde sağlanmazsa `TimeoutError` fırlatır. `fill()`, `inner_text()` gibi tek öğeyle çalışan çağrılar da öğenin ortaya çıkmasını bekler.

Bunun sınırı var: otomatik bekleme eylemler içindir, sayımlar için değil. Yukarıdaki örnekte `quotes.count()` beklemeden `0` döndü. Playwright'ın API belgesi `locator.all()` için de aynı notu düşer: eşleşen öğeleri beklemez, o an sayfada ne varsa onu verir. Liste okuyacaksanız önce `first.wait_for()` ile ilk öğeyi bekleyin. "Playwright'ta bekleme yazılmaz" cümlesi bu yüzden yarı doğrudur.

İkinci fark öğe başvurusundadır. Selenium'da `find_element` o anki DOM düğümüne bir başvuru döndürür; sayfa o bölümü yeniden çizerse başvuru bayatlar ve `StaleElementReferenceException` alırsınız. Playwright'ta `locator` bir tariftir, her kullanımda yeniden çözülür; aynı hata pek görülmez. Seçici dili iki araçta da size kalır: [CSS Selector ve XPath: Web Scraping İçin Hangisi?](/tr/blog/css-selector-vs-xpath).

## Proxy yönetimi nasıl farklılaşır?

Playwright tarafını kardeş yazıda anlattık, burada özetliyoruz: `proxy` nesnesi `launch()` ya da `new_context()` çağrısına verilir, `username` ve `password` ayrı alanlardır, tek tarayıcıda her context ayrı bir IP'den çıkabilir. Context; çerezleri, depolamayı ve proxy'yi yalıtır. Tarayıcı ve makine aynı kaldığı için [tarayıcı parmak izi](/tr/blog/browser-fingerprinting) context'ler arasında değişmez; context bir oturum ayracıdır, ayrı bir cihaz değildir.

Selenium'da proxy bir oturum yeteneğidir (capability): tarayıcı başlarken verilir ve o tarayıcının bütün sekmelerini bağlar; farklı bir proxy için `driver.quit()` ile kapatıp yeni bir tarayıcı açarsınız. Kimlik doğrulama tarafı ise standardın kendisinde eksiktir. [W3C WebDriver'ın proxy tanımı](https://www.w3.org/TR/webdriver2/#proxy) `httpProxy`, `sslProxy`, `socksProxy`, `socksVersion` ve `noProxy` anahtarlarını sayar; kullanıcı adı ya da parola için bir anahtar yoktur. Selenium'un resmî örneği de yalnızca `<HOST:PORT>` biçimini gösterir. Standart, sunucu adresinin kimlik bilgisi taşıyabileceğini söyler, ama [Chromium'un proxy belgesi](https://chromium.googlesource.com/chromium/src/+/HEAD/net/docs/proxy.md#Proxy-credentials-in-manual-proxy-settings) Chrome'un proxy ayarına gömülü kimlik bilgisini kullanmadığını yazar.

Bunun pratikte neye yol açtığını kimlik doğrulama isteyen yerel bir proxy ile denedik. Sonuçlar bu makinedeki tek koşulara aittir (Selenium 4.49, Chrome 153):

| Denediğimiz | Ne oldu |
|---|---|
| `--proxy-server=http://sunucu:port`, kimlik bilgisi yok | Proxy `407` döndü. `driver.get()` hata fırlatmadı; sayfa boş, `driver.title` boş geldi |
| `--proxy-server=http://user:pass@sunucu:port` | Chrome `ERR_NO_SUPPORTED_PROXIES` hata sayfasını açtı, yine istisna yok |
| `Proxy` nesnesinde `user:pass@sunucu:port` | Sayfa açıldı, ama proxy kaydına tek istek düşmedi: tarayıcı doğrudan, kendi IP'mizle bağlandı |
| Kimlik doğrulama istemeyen port (IP whitelist karşılığı) | Sorunsuz çalıştı |

Üçüncü satır en tehlikelisidir: betik çalışıyor görünür, oysa trafik proxy'den geçmiyordur. Eski yazılarda rastlanan `--proxy-auth` diye bir Chrome argümanı da yoktur. Selenium'un BiDi tarafındaki `add_auth_handler` çağrısı belgede sitenin kendi Basic kimlik doğrulaması için anlatılır; proxy için belgelenmiş bir yol değildir ve proxy tanımlı denememiz sayfa yükleme zaman aşımıyla bitti.

Bu yüzden Selenium'da önerdiğimiz yol IP whitelist'tir: betiğin çalıştığı sunucunun çıkış IP'sini panelde listeye ekler, `--proxy-server` değerini kimlik bilgisi olmadan verirsiniz. İki yöntemin karşılaştırması [Proxy Kimlik Doğrulama: User:Pass ve IP Whitelist](/tr/blog/proxy-authentication-methods) yazımızda, SeleniumBase'in proxy söz dizimi ise [SeleniumBase ile Proxy Nasıl Kullanılır?](/tr/blog/seleniumbase-ile-proxy) yazısında.

Aynı koşularda bir gözlem daha yaptık: Selenium'un açtığı kurulu Chrome, hedef sitenin yanında Google'ın güncelleme ve hesap servislerine de proxy üzerinden bağlandı; Playwright'ın kendi Chromium derlemesinde proxy kaydına yalnızca sayfanın istekleri düştü. Trafiği GB ile ödediğiniz [Residential Proxy](https://proxynet.io/tr/residential-proxy) kullanımında bu arka plan trafiğini panelinizden izlemeye değer.

## Dil desteği ve ekosistem

Selenium'un resmî kütüphaneleri Java, Python, C#, Ruby ve JavaScript içindir. Playwright'ınkiler JavaScript ve TypeScript, Python, Java ve .NET. Ruby ekibiyseniz seçim kendiliğinden yapılmış olur.

Kâğıt üstünde diller örtüşse de ağırlık merkezleri farklıdır. Selenium yirmi yıllık bir projedir; Türkiye'de kurumsal test ekiplerinin büyük bölümü Java ya da C# ile Selenium yazar, TestNG, JUnit, NUnit ve Cucumber ile kurulmuş yüzlerce senaryoluk paketler vardır ve bunları yeniden yazmanın maliyeti Playwright'ın kolaylığından çoğu zaman büyüktür. Playwright'ın en olgun yüzü Node.js tarafıdır: kendi test koşucusu paralel çalıştırma, ekran görüntüsü karşılaştırma ve otomatik iz kaydıyla gelir. Python'da önerilen yol pytest eklentisidir. C# ile veri toplamaya [C# ile Web Sitesinden Veri Çekme: HttpClient ve Proxy](/tr/blog/csharp-web-scraping) yazımızda değiniyoruz.

Scraping açısından dil seçimi çoğu zaman aracın önüne geçer: veriyi işleyecek hat Python'daysa iki araç da iş görür, Node.js'teyse Playwright daha doğal durur. İki dilin karşılaştırması [Web Kazıma: JavaScript mi Python mu?](/tr/blog/web-scraping-javascript-vs-python) yazısında.

## Tarayıcı kurulumu: Selenium Manager ve playwright install

Eski Selenium rehberleri, Chrome sürümünüze uyan ChromeDriver'ı elle indirip yolunu `executable_path` ile vermenizi söyler. İkisi de geride kaldı: Selenium 4.49'da `webdriver.Chrome()` yalnızca `options`, `service` ve `keep_alive` parametrelerini kabul ediyor, sürücüyü bulma işini de 4.6 sürümünden beri kütüphaneyle gelen [Selenium Manager](https://www.selenium.dev/documentation/selenium_manager/) yapıyor: kurulu tarayıcının sürümünü saptar, uyan sürücüyü indirir ve `~/.cache/selenium` klasöründe saklar. Denememizde kurulu Chrome 153 için ChromeDriver 153'ü hiçbir ek adım olmadan indirdi. Belgeye göre tarayıcı kurulu değilse Chrome, Firefox ve Edge'i de indirebilir; araç hâlâ beta olarak sürümleniyor.

Playwright'ın yaklaşımı tersidir: sistemdeki tarayıcıya güvenmez. `playwright install chromium` kendi derlemesini indirir ve her Playwright sürümü belirli bir tarayıcı derlemesine sabitlenir. Kütüphaneyi güncelleyip `install` komutunu yeniden çalıştırmayı unutursanız "Executable doesn't exist" hatasını alırsınız; biz de bu yazının denemelerinde aldık.

Takas şudur: Selenium kullanıcılarınızın gerçekten kullandığı, kendiliğinden güncellenen tarayıcıyı sürer, bu test için anlamlıdır ama tarayıcı güncellenince davranış değişebilir. Playwright'ta tarayıcı sürümü kodla kilitlenir; güncellemeyi siz seçersiniz.

## Paralel çalışma: Grid mi, context mi?

Playwright'ta paralelliğin birimi context'tir. Tek tarayıcı süreci açılır, her görev kendi context'ini ve isterse kendi proxy'sini alır:

```python
import asyncio

from playwright.async_api import async_playwright

URLS = [f"https://quotes.toscrape.com/js/page/{n}/" for n in range(1, 4)]
PROXY = {"server": "http://pr.proxynet.io:8000", "username": "user", "password": "pass"}

async def scrape(browser, url):
    context = await browser.new_context(proxy=PROXY)  # yalıtılmış oturum, kendi proxy'si
    try:
        page = await context.new_page()
        await page.goto(url)
        quotes = page.locator("div.quote span.text")
        await quotes.first.wait_for()
        return url, await quotes.count()
    finally:
        await context.close()

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch()  # tek tarayıcı süreci
        for url, count in await asyncio.gather(*(scrape(browser, u) for u in URLS)):
            print(url, count)
        await browser.close()

asyncio.run(main())
```

Selenium'da birim tarayıcının kendisidir. Aynı iş, görev başına bir sürücü açan bir iş parçacığı havuzuyla yazılır:

```python
from concurrent.futures import ThreadPoolExecutor

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait

URLS = [f"https://quotes.toscrape.com/js/page/{n}/" for n in range(1, 4)]

def scrape(url):
    options = webdriver.ChromeOptions()
    options.add_argument("--headless=new")
    options.add_argument("--proxy-server=http://pr.proxynet.io:8000")  # IP whitelist ile
    driver = webdriver.Chrome(options=options)  # görev başına bir tarayıcı süreci
    try:
        driver.get(url)
        quotes = WebDriverWait(driver, 15).until(
            EC.presence_of_all_elements_located((By.CSS_SELECTOR, "div.quote span.text"))
        )
        return url, len(quotes)
    finally:
        driver.quit()

with ThreadPoolExecutor(max_workers=3) as pool:
    for url, count in pool.map(scrape, URLS):
        print(url, count)
```

İki betik de üç sayfadan onar alıntı döndürdü. Fark kaynak tüketimindedir: ilkinde bir, ikincisinde üç tarayıcı ve üç sürücü süreci açılır. Yirmi eşzamanlı oturumda bu fark belleğe doğrudan yansır. Eşzamanlılık ile paralelliğin scraping'de ne zaman işe yaradığı [Concurrency ve Parallelism: Scraping Hızını Ne Belirler?](/tr/blog/concurrency-vs-parallelism) yazımızda.

Selenium'un güçlü olduğu yer makineler arası dağıtımdır. Selenium Grid, komutları uzak makinelerdeki tarayıcılara yönlendirir; resmî belgesine göre amacı testleri birden çok makinede paralel koşmaktır. "Windows'ta Edge, macOS'ta Safari, Linux'ta Firefox" matrisini tek paketle koşturmak Grid'in işidir. Playwright'ın doğrudan karşılığı yoktur: makineler arası dağıtımı CI sisteminize bırakır. Grid'e bağlanma özelliği ise belgesinde deneysel diye işaretlidir ve yalnızca Chromium tabanlı tarayıcıları kapsar.

## Hata ayıklama araçları

Playwright bu başlıkta belirgin biçimde öndedir. `context.tracing.start(screenshots=True, snapshots=True)` ile başlayıp `tracing.stop(path="trace.zip")` ile biten bir kayıt, `playwright show-trace trace.zip` komutuyla açılır: her eylemin öncesi ve sonrası DOM görüntüsü, ağ istekleri, konsol mesajları zaman çizelgesinde durur. Gece çalışan bir tarama neden boş döndü sorusunu sabah bu dosyadan yanıtlarsınız. `PWDEBUG=1` Inspector'ı açıp betiği adım adım yürütür, `playwright codegen` tarayıcıda yaptıklarınızı koda çevirir.

Selenium'da eşdeğer tek bir araç yoktur. `driver.save_screenshot()` ile ekran görüntüsü alır, Chrome'da `goog:loggingPrefs` yeteneğini açıp `driver.get_log("browser")` ile konsol mesajlarını okursunuz; ikisini de denedik, çalışıyor. Kaydet ve oynat ihtiyacını Selenium IDE eklentisi karşılar. Ağ isteklerini canlı dinleme BiDi ile geliyor, ama sonradan gezilen bir kayıt için raporlama çatılarına yaslanırsınız.

## Hız: neden rakam vermiyoruz?

İnternetteki karşılaştırmaların çoğu "Playwright şu kadar daha hızlı" diye bir yüzde taşır; bu rakamlar yazarın kendi makinesinde, kendi sayfasında alınmıştır. Mimari Playwright lehine bir beklenti doğurur: komut başına HTTP isteği yerine açık bir bağlantı, tarayıcı yerine context. Ancak proxy üzerinden çalışan gerçek bir taramada sürenin büyük bölümü ağda ve hedef sitenin yanıt süresinde geçer; bizim örneğimizde iki betik de on saniyelik sayfa gecikmesinin gölgesinde bitti.

Ölçecekseniz kendi hedefinizde, aynı proxy ve eşzamanlılıkla, birkaç on sayfalık bir örnekle ölçün. Çoğu projede asıl kazanç araç değiştirmekten değil, tarayıcıyı gereksiz yere açmamaktan gelir.

## Kullanım alanları

- **Dinamik sayfalardan veri toplama:** yeni projede Playwright'ın ağ dinleme ve kaynak engelleme özellikleri trafiği azaltır; genel kurgu [veri kazıma çözümü](/tr/data-scraping) sayfasında.
- **Çok sayıda sayfanın düzenli taranması:** kuyruk ve keşif mantığı araçtan bağımsızdır; [web crawler çözümü](/tr/web-crawler) sayfasına ve [Sayfalama (Pagination) Nedir, Scraping'de Nasıl Taranır?](/tr/blog/pagination-web-scraping) yazısına bakın.
- **Uygulamanızı farklı ülkelerden test etme:** Playwright'ta ülke başına bir context, Selenium'da ülke başına bir oturum; ayrıntı [uygulama testi](/tr/app-testing) sayfasında.
- **Tarayıcılar arası uyumluluk testi:** gerçek Safari ve işletim sistemi matrisi gerekiyorsa Selenium ve Grid.
- **Bağımsız sayfaların toplu taranması:** iki araçta da [Rotating Proxy](https://proxynet.io/tr/rotating-proxy) ile tek ağ geçidi adresi yeter; rotasyonu ağ geçidi yapar.

Araç ne olursa olsun çerçeve değişmez: `robots.txt` kurallarına ve kullanım şartlarına uyun, resmî API varsa onu kullanın, istek hızını sitenin kaldıracağı düzeyde tutun. Ayrıntı [robots.txt Dosyası Nedir, Nasıl Okunur?](/tr/blog/robots-txt) yazısında.

## Sık yapılan hatalar

- **Selenium'da kimlik bilgisini proxy adresine gömmek.** Chrome bunu kullanmaz; denememizde sonuç ya hata sayfası ya da proxy'siz, doğrudan bağlantı oldu.
- **`driver.get()` hata vermedi diye sayfanın açıldığını varsaymak.** Selenium durum kodunu vermez; beklediğiniz öğeyi ve çıkış IP'sini doğrulayın.
- **Playwright'ta `count()` ya da `all()` çağrısının bekleyeceğini sanmak.** Beklemez; önce `first.wait_for()`.
- **Beklemeyi `time.sleep()` ile çözmek.** Hem yavaş hem kırılgandır; Selenium'da `WebDriverWait`, Playwright'ta locator beklemesi kullanın.
- **Selenium'da örtük ve açık beklemeyi karıştırmak.** Resmî belge uyarır: süreler öngörülemez hale gelir.
- **Selenium'da `driver.quit()` çağırmamak.** Kapatılmayan her oturum bir Chrome ve bir sürücü süreci bırakır; `try/finally` kullanın.
- **Çalışan bir Selenium paketini yalnızca moda diye taşımak.** Geçişin maliyeti seçicilerde değil, bekleme mantığı ve test altyapısındadır.
- **Playwright'ı güncelleyip tarayıcıları güncellememek.** Her sürüm kendi derlemesini ister; CI imajınıza `playwright install` adımını ekleyin.

## Karar rehberi

| İhtiyaç | Öneri |
|---|---|
| Yeni başlayan scraping projesi, Python ya da Node.js | Playwright |
| Kullanıcı adı ve parolayla çalışan proxy | Playwright; Selenium'da IP whitelist'e geçin |
| Tek makinede onlarca bağımsız oturum, oturum başına ayrı IP | Playwright, context başına proxy |
| Çalışan, bakımı yapılan Selenium test paketi | Selenium'da kalın |
| Java ya da C# ağırlıklı kurumsal test ekibi | İkisi de olur; mevcut çatı ve deneyim belirler |
| Ruby | Selenium |
| Gerçek Safari'de ve farklı işletim sistemlerinde test | Selenium ve Grid |
| Gece çalışan işlerde sonradan hata ayıklama | Playwright, Trace Viewer |
| Ağ yanıtını okuma, görsel ve font engelleme | Playwright (yerleşik) |
| Veri sayfa kaynağında ya da JSON uç noktasında | İkisi de değil: düz HTTP istemcisi ya da Scrapy |

## Sıkça sorulan sorular

### Playwright Selenium'un yerini alır mı?

Yeni projelerde sık sık ilk tercih oluyor, ama yerini aldığını söylemek doğru olmaz. Selenium bir W3C standardının başvuru uygulamasıdır, sürücüleri tarayıcı üreticileri yazar ve eksik kalan çift yönlü iletişim WebDriver BiDi ile standart yoluyla ekleniyor. İki proje de etkin geliştiriliyor.

### Selenium'dan Playwright'a geçmek zor mu?

Seçiciler büyük oranda taşınır; CSS ve XPath ikisinde de çalışır. Emek isteyen kısım bekleme mantığıdır: `WebDriverWait` blokları kalkar, yerine locator tabanlı akış gelir; test tarafında sayfa nesneleri, raporlama ve CI adımları da yeniden kurulur. Küçük bir betik bir günde taşınır; yüzlerce senaryoluk bir pakette önce yeni senaryoları Playwright'ta yazıp eskileri yerinde bırakmak daha az risklidir.

### İkisi aynı projede birlikte kullanılabilir mi?

Evet, birbirlerine karışmazlar. Yaygın düzen, mevcut Selenium regresyon paketini korurken yeni işleri Playwright ile yazmaktır. Dikkat edilecek nokta iki ayrı tarayıcı kurulum modelini CI imajında birlikte yönetmektir.

### Selenium'da kullanıcı adı ve parolalı proxy hiç mi kullanılamaz?

Standart yoldan kullanılamaz: WebDriver'ın proxy tanımında kimlik bilgisi alanı yoktur, Chrome da adrese gömülü kimliği kullanmaz. Araya yerel bir yönlendirici proxy koyan üçüncü taraf paketler bu boşluğu doldurur, ama ek bir bağımlılık getirir. Sabit IP'li bir sunucudan çalışıyorsanız IP whitelist hem daha basit hem daha güvenlidir; parola kodda hiç yer almaz.

### Selenium Python'da Playwright'tan daha mı yavaş?

Genel bir yanıt yok. Mimari Playwright lehinedir, ama proxy üzerinden yapılan taramada süreyi çoğunlukla ağ ve hedef site belirler. Yayımlanmış yüzdeleri kendi işinize aktarmayın; aynı hedefte, aynı proxy ve eşzamanlılıkla kendiniz ölçün.

### Headless modda iki araç farklı davranır mı?

İkisi de penceresiz çalışır. Playwright varsayılan olarak headless açılır ve bunun için ayrı bir "headless shell" derlemesi indirir; pencereyi görmek için `launch(headless=False)` yazarsınız. Selenium varsayılan olarak pencereli açılır, Chrome'da `--headless=new` argümanıyla penceresiz moda geçer. Proxy ayarı iki modda da aynıdır.

## Özetle

Playwright ile Selenium aynı işi farklı yollardan yapar. Selenium, komutları W3C WebDriver üzerinden tarayıcı üreticisinin sürücüsüne yollar; daha çok dili, gerçek Safari'yi ve Grid ile makineler arası dağıtımı kapsar, beklemeyi ve proxy kimliğini size bırakır. Playwright tarayıcıyla kalıcı bir bağlantı kurar; kendiliğinden bekler, proxy'yi kullanıcı adı ve parolayla context başına alır, ağ trafiğini dinler ve iz dosyasıyla hata ayıklamayı kolaylaştırır. Yeni bir scraping projesinde Playwright daha az kodla yol aldırır; çalışan bir Selenium paketiniz varsa onu IP whitelist ile proxy'ye bağlamak çoğu zaman yeterlidir. İki araçla da kullanabileceğiniz proxy türlerini [proxy hizmetlerimizde](/tr/proxy) bulabilirsiniz.