Python으로 동적 웹 페이지를 스크래핑하는 방법

동적 웹 페이지를 스크래핑하려면 첫 요청으로 내려받은 HTML에는 없는 콘텐츠를 다뤄야 합니다. 현대적인 사이트는 JavaScript를 사용해 브라우저에서 상품 그리드, 가격, 댓글, 피드를 구성하므로, 단순한 HTTP 가져오기는 데이터가 있어야 할 곳에 빈 껍데기만 반환합니다.

이 가이드는 Python으로 전체 작업 흐름을 안내합니다. 원시 응답과 렌더링된 DOM을 비교해 동적 콘텐츠를 감지하는 것으로 시작한 다음, 가장 저렴한 방법부터 가장 무거운 방법까지 추출 옵션을 다룹니다. 숨겨진 JSON API 찾기, Playwright 또는 Selenium 제어, 무한 스크롤과 더 보기 버튼 처리, 프록시 대역폭 절감, 재시도 추가, 동시 웹 스크래핑, 깔끔한 JSON 및 CSV 내보내기가 포함됩니다.

DataImpulse는 90M개 이상의 레지덴셜 프록시(residential proxy), 모바일 프록시, 데이터센터 프록시 IP 주소를 195개국에서 제공하는 윤리적 프록시 제공업체입니다. 만료되지 않는 트래픽을 GB당 1달러부터 종량제로 제공하며, 웹 스크래핑, 광고 검증, 가격 모니터링, 시장 조사, 다계정 관리에 사용됩니다.

웹 페이지가 동적인 이유는 무엇인가요?

의미 있는 콘텐츠가 최초 HTML 응답으로 전달되지 않고 브라우저에서 JavaScript로 생성될 때 페이지는 동적입니다. 서버는 가벼운 골격을 보내고, 이후 클라이언트 측 코드가 데이터를 가져와 페이지가 열린 뒤 DOM에 삽입합니다.

가장 빠른 수동 확인 방법은 동일한 페이지의 두 보기를 비교하는 것입니다. 마우스 오른쪽 버튼을 클릭해 View Source를 선택하면 서버가 반환한 원시 HTML을 볼 수 있고, 개발자 도구를 열어 스크립트 실행 후의 실시간 DOM을 보여 주는 Elements 패널을 검사할 수 있습니다. 원하는 가격이나 목록이 Elements 패널에는 있지만 View Source에는 없다면 콘텐츠는 동적이며 단일 요청으로는 캡처할 수 없습니다.

• 정적 콘텐츠 는 View Source에 있으며 HTTP 응답에서 바로 파싱할 수 있습니다.
• 동적 콘텐츠 는 렌더링된 DOM에만 나타나며 백그라운드 요청을 통해 로드됩니다.

이 진단은 코드로 자동화할 수 있습니다. 먼저 일반 HTTP 클라이언트가 내려받는 원시 HTML의 대상 요소 수를 셉니다:

import requests
from bs4 import BeautifulSoup

url = "https://example.com/products"
headers = {"User-Agent": "Mozilla/5.0"}

resp = requests.get(url, headers=headers, timeout=30)
soup = BeautifulSoup(resp.text, "html.parser")

raw_cards = soup.select("div.product-card")
print("Cards in raw HTML:", len(raw_cards))

# If this prints 0 but the page clearly shows products in a browser,
# the content is injected by JavaScript and the page is dynamic.

그런 다음 헤드리스 브라우저에서 같은 URL을 렌더링하고 다시 셉니다. 두 수의 차이가 증거입니다:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://example.com/products", wait_until="networkidle")
    rendered_cards = page.query_selector_all("div.product-card")
    print("Cards after JavaScript runs:", len(rendered_cards))
    browser.close()

# Raw HTML 0, rendered DOM 48 means the page builds its content dynamically.

전체 스크래퍼를 작성하기 전에 대상이 자동화된 접근을 허용하는지도 확인하는 것이 좋습니다. 사이트가 스크래핑을 허용하는지 확인하는 방법 가이드에서는 robots 규칙과 서비스 약관을 읽는 방법을 다룹니다.

동적 페이지 스크래핑에는 어떤 방법을 사용해야 하나요?

데이터를 안정적으로 반환하는 가장 가벼운 방법을 선택하세요. 숨겨진 JSON API가 있으면 이를 호출하고, 없을 때만 헤드리스 브라우저를 사용합니다. 각 옵션은 재현할 수 있는 페이지의 범위와 속도 및 비용 사이에서 절충합니다.

아래 표는 코드를 작성하기 전에 선택할 수 있도록 흔히 쓰는 네 가지 접근 방식을 비교합니다. 실제로 대부분의 프로젝트는 두 가지를 결합하여 대량 로드에는 숨겨진 API를, 이에 잘 대응하지 않는 페이지에는 브라우저를 사용합니다.

비용이 중요한 이유는 종량제 프록시를 거치는 헤드리스 브라우저가 단일 API 호출보다 훨씬 많은 바이트를 내려받기 때문입니다. 대규모로 웹 스크래핑하는 경우 선택하는 방법은 코드만큼이나 비용에 영향을 줍니다. 요청 속도 조절과 헤더에 관한 더 폭넓은 지침은 웹 스크래핑 모범 사례를 참조하세요.

동적 페이지 뒤에 숨은 API는 어떻게 찾나요?

페이지가 데이터를 가져오기 위해 보내는 백그라운드 요청을 찾으세요. 해당 엔드포인트는 보통 직접 호출할 수 있는 깔끔한 JSON을 반환합니다. 이는 가장 빠르고 신뢰할 수 있는 접근 방식이며 브라우저 실행을 완전히 피할 수 있습니다.

개발자 도구를 열고 Network 탭으로 전환한 뒤 Fetch/XHR로 필터링하고 페이지를 새로고침하세요. 콘텐츠가 나타날 때 원하는 값이 포함된 JSON을 반환하는 요청을 찾습니다. 요청 URL, 메서드, 쿼리 매개변수, 전송되는 헤더 또는 토큰을 검사한 다음 마우스 오른쪽 버튼을 클릭해 cURL로 복사하면 전체 형태를 확인할 수 있습니다. HTTP 클라이언트로 그 호출을 재현할 수 있으면 렌더링을 완전히 건너뛰고 훨씬 적은 비용으로 구조화된 데이터를 가져올 수 있습니다.

다음은 프록시를 통해 JSON 엔드포인트를 호출하고 필드를 직접 읽는 최소 예시입니다:

import requests

proxy = "http://USERNAME:[email protected]:823"
proxies = {"http": proxy, "https": proxy}

headers = {
    "User-Agent": "Mozilla/5.0",
    "Accept": "application/json",
    "Referer": "https://example.com/products",
}
params = {"category": "laptops", "page": 1}

r = requests.get(
    "https://example.com/api/v2/products",
    headers=headers,
    params=params,
    proxies=proxies,
    timeout=30,
)
r.raise_for_status()
data = r.json()

for item in data["items"]:
    print(item["name"], item["price"])

엔드포인트가 페이지네이션을 사용하면 page 매개변수를 증가시키거나 응답이 반환하는 다음 커서를 따르세요. 요청에 토큰이 필요하면 페이지가 처음 토큰을 발급하는 위치를 캡처하고 같은 세션에서 재사용하세요. 호출을 DataImpulse를 통해 라우팅하면 엔드포인트는 서버 주소가 아니라 레지덴셜 IP를 보게 되므로, API가 출처별로 속도를 제한할 때 중요합니다. 프록시 자체에서 인증 문제에 부딪히면 프록시 인증에서 자격 증명 형식을 설명합니다.

Playwright로 동적 페이지를 어떻게 스크래핑하나요?

호출할 수 있는 깔끔한 API가 없다면 Playwright 같은 헤드리스 브라우저를 제어해 JavaScript가 사용자 환경에서와 정확히 동일하게 실행되도록 한 뒤 완성된 DOM을 읽으세요. Playwright는 안정적인 자동 대기, 우수한 비동기 지원, 간단한 프록시 옵션을 제공하므로 현대적인 기본 선택입니다.

먼저 설치하고 브라우저 바이너리를 내려받으세요:

pip install playwright
playwright install chromium

핵심 원칙은 고정된 대기 시간을 추측하는 대신 필요한 특정 요소를 기다리는 것입니다. 아래 예시는 Chromium을 실행하고 딕셔너리 형식으로 프록시를 통해 라우팅한 다음 상품 그리드를 기다려 렌더링된 값을 추출합니다:

from playwright.sync_api import sync_playwright

PROXY = {
    "server": "http://gw.dataimpulse.com:823",
    "username": "USERNAME",
    "password": "PASSWORD",
}

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True, proxy=PROXY)
    context = browser.new_context(user_agent="Mozilla/5.0")
    page = context.new_page()
    page.goto("https://example.com/products", wait_until="domcontentloaded")

    page.wait_for_selector("div.product-card", timeout=15000)

    cards = page.query_selector_all("div.product-card")
    for card in cards:
        name = card.query_selector(".title").inner_text()
        price = card.query_selector(".price").inner_text()
        print(name, price)

    browser.close()

대기는 대부분의 동적 스크래퍼의 성패를 가르는 지점이므로 네 가지 전략과 각각 적합한 경우를 알아두는 것이 도움이 됩니다. 장시간 연결을 유지하는 페이지에서 멈출 수 있는 networkidle보다 구체적인 선택자나 조건을 기다리는 방식을 우선하세요:

# Wait for a specific element (most reliable)
page.wait_for_selector("div.product-card", timeout=15000)

# Wait for the initial DOM to be built, before every script finishes
page.goto(url, wait_until="domcontentloaded")

# Wait until there are no network connections for 500 ms
page.goto(url, wait_until="networkidle")

# Wait for a custom condition, such as a minimum item count
page.wait_for_function(
    "document.querySelectorAll('div.product-card').length > 20"
)

대상이 브라우저에서 실행되는 스크립트에 크게 의존한다면 JavaScript를 사용한 웹 스크래핑에서는 이러한 페이지를 어렵게 만드는 클라이언트 측 렌더링을 더 자세히 다룹니다.

무한 스크롤과 더 보기 버튼은 어떻게 처리하나요?

페이지가 추가 콘텐츠를 로드할 때 사용하는 것과 같은 이벤트를 트리거한 후, 각 새 배치가 렌더링될 때까지 기다린 뒤 읽으세요. 무한 스크롤과 더 보기 버튼은 사용자의 동작에 따라 데이터를 가져오므로, 한 번의 페이지 로드로는 첫 화면만 캡처됩니다.

브라우저를 사용하기 전에 Network 탭을 다시 확인하세요. 무한 스크롤은 거의 항상 페이지네이션된 XHR 호출로 작동하며, 위의 requests 접근 방식으로 해당 엔드포인트를 반복 호출하는 편이 스크롤보다 훨씬 저렴합니다. 반드시 스크롤해야 한다면 새 항목이 더 이상 나타나지 않을 때 멈추는 제어된 루프를 사용하세요:

def scroll_until_stable(page, item_selector, max_rounds=30):
    seen = 0
    for _ in range(max_rounds):
        page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
        page.wait_for_timeout(1500)
        count = len(page.query_selector_all(item_selector))
        if count == seen:
            break            # no new items loaded, stop
        seen = count
    return seen

스크롤 대신 명시적인 버튼을 사용하는 페이지에는 클릭 루프가 필요합니다. 매 클릭 전에 항목 수를 읽고 버튼을 클릭한 뒤 수가 증가할 때까지 기다리면 렌더링보다 앞서가지 않습니다:

def click_load_more(page, button_selector, item_selector, max_clicks=50):
    for _ in range(max_clicks):
        button = page.query_selector(button_selector)
        if button is None or not button.is_visible():
            break
        before = len(page.query_selector_all(item_selector))
        button.click()
        page.wait_for_function(
            "([sel, n]) => document.querySelectorAll(sel).length > n",
            arg=[item_selector, before],
        )
    return len(page.query_selector_all(item_selector))

수집하면서 중복을 제거하세요. 매번 같은 노드를 다시 읽는 일이 흔하기 때문입니다. 고유 ID 또는 URL 집합을 유지하고 아직 보지 못한 레코드만 추가하세요.

Playwright 대신 Selenium을 사용할 수 있나요?

예. Selenium도 같은 방식으로 실제 브라우저를 제어하며, 팀에서 이미 사용하거나 폭넓은 언어 지원이 필요할 때 탄탄한 선택입니다. 패턴은 Playwright와 같습니다. 페이지를 로드하고 WebDriverWait로 조건을 기다린 다음 렌더링된 DOM에서 요소를 읽습니다.

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

options = Options()
options.add_argument("--headless=new")
options.add_argument("--proxy-server=http://gw.dataimpulse.com:823")

driver = webdriver.Chrome(options=options)
driver.get("https://example.com/products")

WebDriverWait(driver, 15).until(
    EC.presence_of_element_located((By.CSS_SELECTOR, "div.product-card"))
)

for card in driver.find_elements(By.CSS_SELECTOR, "div.product-card"):
    name = card.find_element(By.CSS_SELECTOR, ".title").text
    price = card.find_element(By.CSS_SELECTOR, ".price").text
    print(name, price)

driver.quit()

한 가지 주의할 점은 일반 –proxy-server 플래그가 사용자 이름과 비밀번호를 받지 않으므로 인증 프록시에는 도우미가 필요하다는 것입니다. Selenium Wire 라이브러리는 자격 증명을 깔끔하게 주입하며, Selenium Wire 프록시 설정 안내에서는 정확한 구성을 보여 줍니다. Selenium은 Playwright보다 설정이 무겁고 대기가 더 장황하므로, 새 프로젝트는 Selenium을 유지해야 할 이유가 없는 한 흔히 Playwright로 시작합니다.

페이지 렌더링 시 프록시 대역폭은 어떻게 줄이나요?

필요하지 않은 리소스를 차단하여 브라우저가 파싱하지 않을 이미지, 글꼴, 미디어를 내려받지 않도록 하세요. 헤드리스 브라우저는 기본적으로 모든 자산을 가져오며, GB당 가격이 매겨진 프록시를 거치면 그 바이트마다 비용이 듭니다.

Playwright를 사용하면 요청을 가로채 추출과 관련 없는 요청을 중단할 수 있습니다. 이미지, 미디어, 글꼴을 차단하면 실제로 읽는 JSON과 HTML은 그대로 두고 프록시 트래픽을 크게 줄일 수 있습니다:

BLOCK = {"image", "media", "font"}

def block_heavy(route):
    if route.request.resource_type in BLOCK:
        route.abort()
    else:
        route.continue_()

context = browser.new_context()
context.route("**/*", block_heavy)
page = context.new_page()
page.goto("https://example.com/products", wait_until="domcontentloaded")

같은 핸들러를 확장해 데이터는 추가하지 않으면서 부하만 더하는 분석 및 광고 도메인을 건너뛸 수 있습니다. DataImpulse 트래픽은 GB당 1달러부터 종량제로 청구되고 만료되지 않으므로, 낭비되는 바이트를 줄이면 각 스크래핑 비용이 직접 낮아집니다. 관련 페이지에서 하나의 브라우저 컨텍스트를 재사용하면 반복되는 시작 비용도 피할 수 있으며, 숨겨진 API로 전환하여 피할 수 있는 요청이 여전히 가장 저렴합니다.

오류 처리와 재시도는 어떻게 추가하나요?

각 탐색을 지수 백오프를 적용한 재시도 루프로 감싸서 한 번의 느린 로드나 일시적 차단이 전체 실행을 중단시키지 않도록 하세요. 동적 페이지는 간헐적으로 실패하며, 첫 번째 시간 초과에서 포기하는 스크래퍼는 대규모 작업에서 상당한 비율의 레코드를 잃게 됩니다.

Playwright가 발생시키는 시간 초과를 잡고 점점 늘어나는 간격으로 대기한 뒤, 정해진 횟수만큼 재시도하고 실패를 기록한 후 다음으로 진행하세요:

import time
from playwright.sync_api import TimeoutError as PlaywrightTimeout

def fetch_with_retries(page, url, selector, retries=3, backoff=2):
    for attempt in range(1, retries + 1):
        try:
            page.goto(url, wait_until="domcontentloaded", timeout=30000)
            page.wait_for_selector(selector, timeout=15000)
            return page.query_selector_all(selector)
        except PlaywrightTimeout:
            wait = backoff ** attempt
            print(f"Attempt {attempt} timed out, retrying in {wait}s")
            time.sleep(wait)
    raise RuntimeError(f"Failed to load {url} after {retries} attempts")

재시도를 프록시 로테이팅과 결합해 각 시도가 새로운 IP를 통해 나가도록 하세요. 하나의 출구가 속도 제한되면 다음 요청은 다른 주소로 전달되어 흔히 성공합니다. 레지덴셜 프록시 또는 모바일 프록시의 로테이팅 풀은 요청마다 새 IP를 자동 할당하여 많은 강한 차단을 단순한 재시도로 바꿉니다. 프록시 수준의 실패를 구체적으로 처리하려면 HTTP 오류 407에서 가장 흔한 인증 응답을 다룹니다.

여러 동적 페이지를 동시에 어떻게 스크래핑하나요?

asyncio 세마포어와 Playwright의 비동기 API를 사용해 컴퓨터나 대상을 과부하하지 않고 여러 페이지를 한 번에 렌더링하세요. 각 브라우저 페이지는 대부분의 시간을 네트워크 대기에 쓰므로, 동시성은 동적 웹 스크래핑의 처리량을 회복하는 지점입니다.

세마포어는 병렬로 실행되는 페이지 수를 제한합니다. 작업 간에 하나의 브라우저와 컨텍스트를 공유하고 URL마다 페이지를 열어 결과를 수집하세요:

import asyncio
from playwright.async_api import async_playwright

PROXY = {
    "server": "http://gw.dataimpulse.com:823",
    "username": "USERNAME",
    "password": "PASSWORD",
}

async def scrape_one(context, url, sem):
    async with sem:
        page = await context.new_page()
        try:
            await page.goto(url, wait_until="domcontentloaded")
            await page.wait_for_selector("div.product-card", timeout=15000)
            cards = await page.query_selector_all("div.product-card")
            return [await c.inner_text() for c in cards]
        finally:
            await page.close()

async def main(urls):
    sem = asyncio.Semaphore(5)   # at most 5 pages at once
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True, proxy=PROXY)
        context = await browser.new_context()
        tasks = [scrape_one(context, u, sem) for u in urls]
        results = await asyncio.gather(*tasks)
        await browser.close()
    return results

urls = ["https://example.com/products?page=%d" % i for i in range(1, 21)]
data = asyncio.run(main(urls))

동시성 제한은 적절한 수준으로 유지하세요. 병렬 페이지가 너무 많으면 메모리를 소진하고 속도 제한에 걸려, 병렬 처리로 절약한 것보다 재시도 비용이 더 커집니다. 약 다섯 개에서 시작해 성공률이 높게 유지되는 동안에만 늘리세요.

스크래핑한 데이터를 JSON 및 CSV로 어떻게 내보내나요?

각 페이지의 결과를 딕셔너리 목록으로 수집한 다음, 중첩 데이터에는 JSON으로, 평면적이고 스프레드시트에 적합한 표에는 CSV로 해당 목록을 작성하세요. 추출과 내보내기를 분리하면 스크래퍼를 테스트하고 다시 실행하기가 쉬워집니다.

import json
import csv

records = [
    {"name": "Laptop A", "price": "999"},
    {"name": "Laptop B", "price": "1299"},
]

# Export to JSON
with open("products.json", "w", encoding="utf-8") as f:
    json.dump(records, f, ensure_ascii=False, indent=2)

# Export to CSV
with open("products.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "price"])
    writer.writeheader()
    writer.writerows(records)

레코드에 중첩 목록이나 객체가 있으면 JSON을, 모든 레코드가 같은 평면 필드를 공유하고 분석가가 스프레드시트에서 열면 CSV를 선택하세요. 작성하기 전에 필드를 정규화하여 모든 레코드가 같은 키를 갖게 하면, 동적 페이지가 어떤 방식으로 렌더링되었든 내보내기 단계는 간단하게 유지됩니다. 여기서 같은 JSON을 추가 파싱 없이 데이터베이스 로드나 분석 작업에 사용할 수 있습니다.

자주 묻는 질문

관련 가이드

• JavaScript를 사용한 웹 스크래핑
• Selenium Wire에서 프록시 설정하기
• 웹 스크래핑 모범 사례

신뢰할 수 있는 프록시로 동적 페이지 스크래핑하기

스크래퍼에 실제 방문자처럼 동작하는 레지덴셜, 모바일 또는 데이터센터 IP가 필요하다면 GB당 1달러부터 종량제 트래픽으로 시작할 수 있습니다. DataImpulse 계정 만들기을 통해 동적 웹 스크래핑을 로테이팅 또는 스티키 세션으로 라우팅하세요.