Target.com เป็นหนึ่งในเว็บที่ดูเหมือนจะดึงข้อมูลง่าย — จนกว่าคุณจะลองทำจริง ถ้าคุณเคยเขียนสคริปต์ Python สั้น ๆ ด้วย Requests กับ BeautifulSoup แล้วยิงไปที่หน้าสินค้าของ Target แล้วพบว่าฟิลด์ราคากลับมาเป็น None คุณไม่ได้เจอปัญหานี้คนเดียวแน่ ๆ
จากการทดสอบวิธีดึงข้อมูลกับเว็บค้าปลีกหลัก ๆ เกือบทั้งหมด ผมยืนยันได้ว่า Target ติดอันดับเว็บที่ยากที่สุดอยู่เสมอ ด้วยจำนวนผู้เข้าชมเดือนละ 208–280 ล้านครั้ง มันเป็นขุมทรัพย์ของข้อมูลสินค้า — ราคา คะแนน รีวิว สต็อก — แต่การเรนเดอร์ฝั่งไคลเอนต์ด้วย React ร่วมกับระบบตรวจจับบอทของ Akamai ทำให้วิธีแบบเดาง่าย ๆ ล้มเหลวแทบจะทันที ถึงอย่างนั้นก็ยังมี 3 วิธีด้วย Python ที่ใช้ได้จริง เดี๋ยวผมจะพาไล่ทีละวิธี อธิบายว่าทำไมวิธีแรกถึงพังเสมอ และโชว์ทางลัดแบบไม่ต้องเขียนโค้ดสำหรับตอนที่การใช้ Python ไม่คุ้มกับความปวดหัว
ทำไมการดึงข้อมูล Target.com ด้วย Python ครั้งแรกถึงได้ None
ก่อนจะไปหาทางแก้ มาดูปัญหาก่อน นี่คือโค้ดที่มือใหม่ส่วนใหญ่มักเขียน:
import requests
from bs4 import BeautifulSoup
url = "https://www.target.com/p/some-product/-/A-12345678"
response = requests.get(url, headers={"User-Agent": "Mozilla/5.0"})
soup = BeautifulSoup(response.text, "html.parser")
price = soup.select_one('[data-test="current-price"]')
print(price) # None
ผลลัพธ์คืออะไร? None ทุกครั้ง
นี่ไม่ใช่บั๊กในโค้ดของคุณ HTML ที่ requests.get() ดึงกลับมาจาก Target แทบจะเป็นแค่โครงเปล่า ๆ — เหมือนเปลือก React ที่บอกว่า “เฮ้ โหลด JavaScript นี้เพื่อเรนเดอร์หน้าจริงที” ราคา คะแนน รีวิว และสถานะสินค้า ถูกเติมเข้ามาด้วย JavaScript หลังจาก หน้าโหลดครั้งแรกไปแล้ว เพราะ Requests ของ Python ไม่ได้รัน JavaScript องค์ประกอบเหล่านั้นจึงไม่มีอยู่ใน response ตั้งแต่ต้น
ในฟอรัมต่าง ๆ เต็มไปด้วยนักพัฒนาที่ชนกำแพงนี้เข้าอย่างจัง มีบทวิเคราะห์จาก ScrapeOps ที่พูดตรง ๆ ว่า “องค์ประกอบแสดงเป็น None เพราะมันถูกเรนเดอร์ด้วย Javascript และ requests ไม่สามารถดึง HTML ที่เรนเดอร์ด้วย Javascript ได้” ส่วน Crawlbase ก็ยืนยันว่า “เมื่อคุณส่ง HTTP request ไปยัง URL ของ Target HTML response จะไม่มีข้อมูลที่มีความหมายอยู่เลย”
และถึงคุณจะข้ามปัญหา JavaScript ได้ ก็ยังมีอีกชั้นหนึ่ง: ระบบตรวจจับบอทของ Akamai ที่สแกนลายนิ้วมือ TLS handshake ของคุณ และมองว่าไลบรารี requests ของ Python น่าสงสัยตั้งแต่ยังไม่ส่งข้อมูล HTML ออกมาแม้แต่ไบต์เดียว เดี๋ยวผมจะอธิบายเรื่องนี้ต่ออีกหน่อย
อะไรทำให้ Target.com ดึงข้อมูลด้วย Python ยากขนาดนี้
Target ไม่ใช่แค่ “เว็บที่ใช้ JavaScript” แต่มันคือระบบป้องกันแบบหลายชั้น — และการเข้าใจแต่ละชั้นคือกุญแจในการเลือกวิธีดึงข้อมูลที่เหมาะสม
ข้อมูลสินค้าที่เรนเดอร์ด้วย JavaScript
Target.com สร้างด้วย React พอคุณโหลดหน้าสินค้าหรือหน้าค้นหาในเบราว์เซอร์จริง จะเกิดขั้นตอนนี้:
- เซิร์ฟเวอร์ส่ง HTML โครงขั้นต่ำมาให้
- โหลดและรัน JavaScript bundles
- ฝั่งหน้าเว็บเรียก API ภายในของ Target ที่ชื่อ Redsky
- ข้อมูลสินค้า (ราคา คะแนน รูปภาพ ความพร้อมจำหน่าย) ถูกเรนเดอร์ลง DOM
ถ้าคุณข้ามขั้นตอน 2–4 — ซึ่งก็คือสิ่งที่ requests.get() ทำพอดี — คุณจะได้หน้าเปล่า ๆ GroupBWT ทดสอบเรื่องนี้ไว้แล้ว โดยพบว่า HTTP request แบบสแตติกดึงข้อมูลได้เพียงราว 30% ของข้อมูลที่มีบน Target ส่วนอีก 70% ต้องอาศัยการรัน JavaScript หรือเรียก API โดยตรง
หน้าผลการค้นหายิ่งแย่กว่าเดิม เพราะตอน HTML แรกโหลดมา มีสินค้าแค่ไม่กี่รายการเท่านั้น ที่เหลือจะค่อย ๆ โหลดเมื่อคุณเลื่อนหน้า
ระบบป้องกันบอทของ Target: ไม่ใช่แค่คำแนะนำกว้าง ๆ แบบ “ใช้พร็อกซี”
ไกด์ดึงข้อมูลส่วนใหญ่มักพูดข้ามระบบป้องกันบอทด้วยคำว่า “ก็ใช้พร็อกซีสิ” แต่ของ Target ซับซ้อนกว่านั้นมาก
TLS Fingerprinting (ตัวใหญ่สุด). ระหว่าง HTTPS handshake ไคลเอนต์ของคุณจะส่งแพ็กเก็ต “Client Hello” ที่บอกเวอร์ชัน TLS ชุด cipher suites ส่วนขยาย และ elliptic curves จากนั้นข้อมูลเหล่านี้จะถูกแฮชเป็นลายนิ้วมือ JA3 ไลบรารี requests ของ Python สร้าง hash แบบตายตัวที่รู้กันอยู่แล้ว คือ 8d9f7747675e24454cd9b7ed35c58707 ซึ่งฐานข้อมูลกันบอทจะปักธงทันที Chrome จะส่ง cipher suites 16 ตัวที่เรียงลำดับอย่างระมัดระวังพร้อมค่า GREASE แต่ Python ส่งมากกว่า 60 ตัวในลำดับที่ไม่เหมือนเบราว์เซอร์จริง การบล็อกเกิดขึ้นก่อนที่จะมีการแลกเปลี่ยนเนื้อหา HTTP ด้วยซ้ำ
การประเมินชื่อเสียงของ IP. Akamai แบ่ง IP ออกเป็นระดับความน่าเชื่อถือ ตามที่ Scrapfly อธิบายไว้ ว่า IP ในดาต้าเซ็นเตอร์จะได้รับ “คะแนนความน่าเชื่อถือติดลบอย่างมาก เพราะมีแนวโน้มถูกใช้โดยบอท” ส่วน IP บ้านจะได้คะแนนบวก สำหรับ Target โดยเฉพาะ ช่วง IP ของดาต้าเซ็นเตอร์จะถูกจับทันที
JavaScript fingerprinting. Akamai แทรก JavaScript ที่เก็บสเปกของ JS engine, ความสามารถของฮาร์ดแวร์, ข้อมูลระบบปฏิบัติการ, ฟอนต์, ปลั๊กอิน และข้อมูลพฤติกรรม เช่น ความเร็วในการพิมพ์ การขยับเมาส์ และจังหวะการคลิก ข้อมูลเหล่านี้ถูกใช้สร้างคุกกี้ _abck ซึ่งเป็นโทเคนลายนิ้วมือแบบมีสถานะ ถ้าไม่มี _abck ที่ถูกต้อง คำขอจะถูกบล็อก
การจำกัดอัตรา. Target เริ่มส่งข้อผิดพลาด 429 ที่ประมาณ 30–60 requests ต่อนาทีต่อ IP ผู้ใช้บางรายรายงานว่าได้รับ response 200 OK แบบหลอกตา แต่ข้างในจริง ๆ เป็นหน้า “Pardon Our Interruption” ซึ่งทำให้ระบบตรวจจับอัตโนมัติยากขึ้น
ScrapeOps ให้คะแนนความยากของ Target ไว้ที่ 7/10 โดยรวม ส่วนการหลบ Akamai โดยเฉพาะ ได้ 9/10
3 วิธีดึงข้อมูล Target.com ด้วย Python (เทียบกันชัด ๆ)
ยังไม่มีบทความไหนที่เปรียบเทียบทั้ง 3 วิธีที่ใช้ได้จริงไว้ในที่เดียว นี่คือภาพรวมแบบตรงไปตรงมา:
| เกณฑ์ | Requests + BS4 | Selenium / Playwright | Redsky API |
|---|---|---|---|
| รองรับการเรนเดอร์ JS | ❌ ไม่ได้ | ✅ ได้ | ✅ ได้ (JSON) |
| ความเร็วต่อรายการ | ⚡ ~0.5–1 วินาที | 🐢 ~5–10 วินาที | ⚡ ~0.5–1 วินาที |
| ความเสี่ยงโดนกันบอท | ⚠️ สูง (TLS fingerprint) | ⚠️ ปานกลาง | ⚠️ ปานกลาง (คีย์อาจเปลี่ยน) |
| ความซับซ้อนตอนตั้งค่า | ต่ำ | ปานกลาง | ปานกลาง-สูง (ต้อง reverse-engineer) |
| ความครบของข้อมูล | ~30% (เฉพาะ HTML สแตติก) | ~95% (ทั้งหน้า) | ~90% (JSON แบบมีโครงสร้าง) |
| เหมาะที่สุดสำหรับ | เมตาดาต้าสแตติก, __TGT_DATA__ | หน้าสินค้าเต็ม ๆ, รีวิว | ดึงข้อมูลสินค้าแบบจำนวนมาก |
มาดูแต่ละวิธีกัน
วิธีที่ 1: ดึงข้อมูล Target.com ด้วย Python Requests และ BeautifulSoup
วิธีนี้จะยังดึงราคาที่เรนเดอร์ด้วย JavaScript บนหน้าค้นหาไม่ได้ แต่มันก็เร็ว เบา และดึงข้อมูลได้มากกว่าที่คิด ถ้าคุณรู้ว่าต้องหาอะไร
เคล็ดลับคือ Target ฝังข้อมูลสินค้าบางส่วนไว้ในแท็ก <script> ที่มีตัวแปร __TGT_DATA__ พร้อม __PRELOADED_QUERIES__ JSON blob นี้มีชื่อสินค้า คำอธิบาย ฟีเจอร์ และบางครั้งก็มีราคาบนหน้าสินค้าแต่ละหน้า คุณยังสามารถดึงชื่อสินค้าและ URL จาก HTML ของหน้าผลการค้นหาได้ด้วย
ขั้นตอนที่ 1: ตั้งค่าสภาพแวดล้อม Python
สร้างโฟลเดอร์โปรเจกต์และติดตั้ง dependencies:
mkdir target-scraper && cd target-scraper
python -m venv venv
source venv/bin/activate # บน Windows: venv\Scripts\activate
pip install requests beautifulsoup4 curl_cffi
ให้ใช้ curl_cffi แทน requests ปกติในกรณีนี้ เพราะมันปลอมลายนิ้วมือ TLS ของเบราว์เซอร์ ซึ่งเป็นปัจจัยสำคัญที่สุดในการหลบการบล็อกของ Target จากการทดสอบพบว่า curl_cffi หลบระบบกันบอทได้ 92% เทียบกับ requests ปกติที่ทำได้แค่ 12% — ดีกว่าถึง 15 เท่า
ขั้นตอนที่ 2: ดึงผลการค้นหาของ Target
รูปแบบ URL สำหรับค้นหาของ Target ค่อนข้างตรงไปตรงมา: https://www.target.com/s?searchTerm={keyword}
from curl_cffi import requests as cureq
from bs4 import BeautifulSoup
import time, random
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.9",
}
url = "https://www.target.com/s?searchTerm=bluetooth+headphones"
resp = cureq.get(url, headers=headers, impersonate="chrome124")
soup = BeautifulSoup(resp.text, "html.parser")
# การ์ดสินค้าใช้ data-test attribute นี้
cards = soup.find_all("div", {"data-test": "@web/site-top-of-funnel/ProductCardWrapper"})
for card in cards:
link_tag = card.find("a")
title = link_tag.get_text(strip=True) if link_tag else "N/A"
href = "https://www.target.com" + link_tag["href"] if link_tag and link_tag.get("href") else "N/A"
print(f"{title} — {href}")
คุณจะได้ชื่อสินค้าและ URL ส่วนราคา? โดยมากจะไม่อยู่ใน HTML นี้ ซึ่งเป็นเรื่องปกติ
ขั้นตอนที่ 3: ดึง JSON ที่ฝังอยู่จากหน้าสินค้า
หน้าสินค้าแต่ละหน้าจะฝังข้อมูลที่ละเอียดกว่าลงในแท็กสคริปต์ __TGT_DATA__:
import re, json
product_url = "https://www.target.com/p/some-product/-/A-12345678"
resp = cureq.get(product_url, headers=headers, impersonate="chrome124")
soup = BeautifulSoup(resp.text, "html.parser")
# หา script ที่มี __TGT_DATA__
scripts = soup.find_all("script")
for script in scripts:
if script.string and "__TGT_DATA__" in script.string:
# ดึง JSON ออกจากเนื้อหา script
match = re.search(r'__TGT_DATA__\s*=\s*({.*?});?\s*$', script.string, re.DOTALL)
if match:
tgt_data = json.loads(match.group(1))
# ไล่โครงสร้าง JSON เพื่อหาข้อมูลสินค้า
queries = tgt_data.get("__PRELOADED_QUERIES__", {})
# ข้อมูลสินค้าถูกซ้อนอยู่ข้างใน — โครงสร้างจะแตกต่างกันไปตามหน้า
print(json.dumps(queries, indent=2)[:500]) # ดูตัวอย่างโครงสร้าง
โครงสร้าง JSON ภายใน __TGT_DATA__ มีชื่อสินค้า คำอธิบาย ฟีเจอร์ และมักมีข้อมูลราคาอยู่ด้วย แต่ชั้นการซ้อนจะแตกต่างกันไป คุณจึงต้องตรวจดูผลลัพธ์แล้วไล่โครงสร้างต่อเอง
ขั้นตอนที่ 4: จัดการแบ่งหน้า
การแบ่งหน้าผลการค้นหาของ Target ใช้พารามิเตอร์ Nao หน้า 1 คือ Nao=0 หน้า 2 คือ Nao=24 หน้า 3 คือ Nao=48 และต่อไปเรื่อย ๆ (เพิ่มทีละ 24):
for page in range(0, 120, 24): # 5 หน้าแรก
paginated_url = f"https://www.target.com/s?searchTerm=bluetooth+headphones&Nao={page}"
resp = cureq.get(paginated_url, headers=headers, impersonate="chrome124")
# parse และดึงข้อมูล...
time.sleep(random.uniform(2, 5)) # ทำแบบสุภาพหน่อย
ขั้นตอนที่ 5: บันทึกข้อมูลที่ดึงมา
import csv
with open("target_products.csv", "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=["title", "url", "price", "description"])
writer.writeheader()
for product in products:
writer.writerow(product)
สิ่งที่คุณจะได้: ชื่อสินค้า URL คำอธิบาย และเมตาดาต้าที่ฝังอยู่ สิ่งที่ยังดึงได้ไม่ค่อยเสถียร: ราคาและคะแนนแบบไดนามิกจากหน้าผลการค้นหา ถ้าต้องการข้อมูลพวกนั้น คุณต้องใช้วิธีที่ 2 หรือ 3
วิธีที่ 2: ดึงข้อมูล Target.com ด้วย Selenium หรือ Playwright
เบราว์เซอร์แบบ headless จะเรนเดอร์ JavaScript โหลดเนื้อหาแบบไดนามิก และจำลองพฤติกรรมผู้ใช้จริง วิธีนี้แหละที่ดึงราคา คะแนน และรีวิวได้
ถ้าถามว่า Selenium กับ Playwright อันไหนดีกว่า: Playwright แซง Selenium ไปแล้วในแง่การใช้งาน — 45.1% เทียบกับ 22.1% ในปี 2026 — และจากเบนช์มาร์กมัน เร็วกว่า 2.5 เท่า (11 วินาที เทียบกับ 28 วินาทีสำหรับ 20 หน้า) ผมจะยกตัวอย่างด้วย Selenium ที่นี่เพราะชุมชนใหญ่กว่าและมีบทเรียนเยอะกว่า แต่ถ้าคุณเริ่มใหม่ Playwright คือทางเลือกที่ดีกว่า
ขั้นตอนที่ 1: ติดตั้ง Selenium และ ChromeDriver
pip install selenium webdriver-manager
webdriver-manager จะจัดการเวอร์ชัน ChromeDriver ให้อัตโนมัติ — ไม่ต้องปวดหัวกับปัญหา “ChromeDriver version mismatch” อีกต่อไป:
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from webdriver_manager.chrome import ChromeDriverManager
options = Options()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")
options.add_argument("--disable-blink-features=AutomationControlled")
options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36")
driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
ขั้นตอนที่ 2: โหลดหน้า Target และรอให้เนื้อหาปรากฏ
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
driver.get("https://www.target.com/s?searchTerm=bluetooth+headphones")
# รอให้การ์ดสินค้าถูกเรนเดอร์ (explicit wait ดีกว่า time.sleep)
WebDriverWait(driver, 15).until(
EC.presence_of_element_located((By.CSS_SELECTOR, '[data-test="product-title"]'))
)
การใช้ explicit wait สำคัญมาก time.sleep(10) ทำให้เสียเวลาบนหน้าที่โหลดเร็ว และก็ยังไม่พอบนหน้าที่โหลดช้า — แย่ทั้งสองทาง WebDriverWait จะคอยตรวจทุก 500 มิลลิวินาทีจนกว่าองค์ประกอบจะปรากฏหรือหมดเวลา
ขั้นตอนที่ 3: เลื่อนหน้าเพื่อโหลดสินค้าทั้งหมด
Target จะ lazy-load สินค้าตอนคุณเลื่อนหน้า ถ้าไม่เลื่อน คุณจะเห็นแค่ 4–5 รายการแทนที่จะเป็นทั้งหน้า:
import time
last_height = driver.execute_script("return document.body.scrollHeight")
for _ in range(10):
driver.execute_script("window.scrollBy(0, 300);")
time.sleep(1.5)
new_height = driver.execute_script("return document.body.scrollHeight")
if new_height == last_height:
break
last_height = new_height
ScrapeOps ทดสอบยืนยันแล้วว่า การเลื่อน 10 รอบด้วยดีเลย์ 1.5 วินาทีจะได้สินค้าราว 8+ รายการ เทียบกับ 4–5 รายการถ้าไม่เลื่อน ควรเลื่อนแต่ละครั้งทีละ 200–300 พิกเซลเพื่อให้ดูเหมือนพฤติกรรมมนุษย์
ขั้นตอนที่ 4: ดึงข้อมูลสินค้าจากหน้าที่เรนเดอร์แล้ว
products = []
cards = driver.find_elements(By.CSS_SELECTOR, '[data-test="@web/site-top-of-funnel/ProductCardWrapper"]')
for card in cards:
try:
title = card.find_element(By.CSS_SELECTOR, '[data-test="product-title"]').text
except:
title = "N/A"
try:
price = card.find_element(By.CSS_SELECTOR, '[data-test="current-price"]').text
except:
price = "N/A"
try:
link = card.find_element(By.CSS_SELECTOR, 'a[href*="/p/"]').get_attribute("href")
except:
link = "N/A"
products.append({"title": title, "price": price, "link": link})
for p in products:
print(f'{p["title"]} — {p["price"]}')
ตัวเลือก data-test สำคัญสำหรับ Target (ยืนยันปี 2026):
| ฟิลด์ข้อมูล | ตัวเลือก |
|---|---|
| การ์ดสินค้า | data-test="@web/site-top-of-funnel/ProductCardWrapper" |
| ชื่อสินค้า | data-test="product-title" |
| ราคาปัจจุบัน | data-test="current-price" |
| ค่าคะแนนรีวิว | data-test="rating-value" |
| จำนวนรีวิว | data-test="rating-count" |
ขั้นตอนที่ 5: ดึงรีวิวสินค้า (โบนัส)
เข้าไปที่หน้าสินค้าแต่ละหน้า เลื่อนลงไปยังส่วนรีวิว แล้วดึงข้อมูลรีวิวออกมา:
from bs4 import BeautifulSoup
driver.get("https://www.target.com/p/some-product/-/A-12345678")
# เลื่อนลงเพื่อโหลดรีวิว
for _ in range(5):
driver.execute_script("window.scrollBy(0, 500);")
time.sleep(2)
soup = BeautifulSoup(driver.page_source, "html.parser")
reviews = soup.find_all("div", {"data-test": "review-card--text"})
for review in reviews:
print(review.get_text(strip=True)[:100])
รีวิวเหล่านี้ถูกโหลดผ่าน Bazaarvoice และรองรับการแบ่งหน้า (มากสุด 51 หน้า) การเรียงตามความใหม่ และตัวกรองเฉพาะรูปภาพ จากเบนช์มาร์กของ ScrapeOps พบว่า Selenium ใช้เวลาประมาณ 5.1 วินาทีต่อรายการ
อย่าลืมปิดเบราว์เซอร์เมื่อเสร็จแล้ว:
driver.quit()
วิธีที่ 3: ดึงข้อมูล Target.com ผ่าน Redsky API
ฝั่งหน้าเว็บของ Target ดึงทุกอย่างจาก API ภายในที่ redsky.target.com คุณสามารถเรียกมันตรง ๆ ด้วย Python ได้เลย — ไม่ต้อง parse HTML ไม่ต้องใช้เบราว์เซอร์ ไม่ต้องเรนเดอร์ JavaScript response จะเป็น JSON ที่สะอาดและมีฟิลด์ข้อมูลกว่า 40 รายการ ครอบคลุมราคา คะแนน รีวิว รูปภาพ ความพร้อมจำหน่าย วิธีจัดส่ง สเปก และตัวแปรสินค้า สำหรับการดึงข้อมูลสินค้าแบบจำนวนมาก นี่คือวิธีที่เร็วและเสถียรที่สุดแบบห่างกันคนละชั้น
ขั้นตอนที่ 1: หา Redsky API ด้วย Chrome DevTools
บทเรียนส่วนใหญ่มักข้ามขั้นตอนนี้ไปเลย นี่คือวิธีหา API ด้วยตัวเอง:
- เปิดหน้าสินค้าใดก็ได้ของ Target ใน Chrome
- เปิด DevTools (F12) → แท็บ Network
- กรองด้วย Fetch/XHR
- รีโหลดหน้า
- มองหาคำขอไปที่
redsky.target.comหรือredsky.a]target.com - คลิกหนึ่งรายการ — ดูที่ Request URL และ Headers
คุณจะเห็นอะไรประมาณนี้:
https://redsky.target.com/redsky_aggregations/v1/web/pdp_fulfillment_v1?key=9f36aeafbe60771e321a7cc95a78140772ab3e96&tcin=12345678&store_id=2148&zip=55401
พารามิเตอร์หลักคือ:
key— API key (คงที่ ไม่ได้หมุนเปลี่ยนตลอด — แต่ละ endpoint ใช้คนละคีย์)tcin— Target.com Item Number (รหัสสินค้า 8 หลัก)store_id— สาขา Target ที่ต้องการอ้างอิงzip— รหัสไปรษณีย์สำหรับข้อมูลการจัดส่ง/รับสินค้า
ดึง API key จาก request headers ได้เลย มันฝังอยู่ใน URL ในรูปแบบ query parameter
ขั้นตอนที่ 2: ส่ง Python request ตรงไปยัง Redsky API
from curl_cffi import requests as cureq
import json
API_KEY = "9f36aeafbe60771e321a7cc95a78140772ab3e96" # ดึงจาก DevTools
TCIN = "12345678"
url = f"https://redsky.target.com/redsky_aggregations/v1/web/pdp_fulfillment_v1?key={API_KEY}&tcin={TCIN}&store_id=2148&zip=55401"
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
"Accept": "application/json",
"Origin": "https://www.target.com",
"Referer": "https://www.target.com/",
"Sec-Fetch-Site": "same-site",
"Sec-Fetch-Mode": "cors",
"Sec-Fetch-Dest": "empty",
}
resp = cureq.get(url, headers=headers, impersonate="chrome124")
data = resp.json()
# ดึงรายละเอียดสินค้าจาก JSON response
product = data.get("data", {}).get("product", {})
title = product.get("item", {}).get("product_description", {}).get("title", "N/A")
price = product.get("price", {}).get("formatted_current_price", "N/A")
rating = product.get("ratings_and_reviews", {}).get("statistics", {}).get("rating", {}).get("average", "N/A")
print(f"{title} — {price} — Rating: {rating}")
ไม่ต้อง parse HTML ให้ยุ่งยาก response มีโครงสร้างชัดเจน สะอาด และเร็ว
ขั้นตอนที่ 3: ดึงผลการค้นหาสินค้าผ่าน API
endpoint product_summary_with_fulfillment_v1 รองรับหลาย TCIN พร้อมกัน:
tcins = ["12345678", "23456789", "34567890"]
tcin_str = ",".join(tcins)
search_url = f"https://redsky.target.com/redsky_aggregations/v1/web/product_summary_with_fulfillment_v1?key={API_KEY}&tcins={tcin_str}&store_id=2148&zip=55401"
resp = cureq.get(search_url, headers=headers, impersonate="chrome124")
results = resp.json()
for item in results.get("data", {}).get("product_summaries", []):
title = item.get("title", "N/A")
price = item.get("price", {}).get("formatted_current_price", "N/A")
print(f"{title} — {price}")
ถ้าจะเอา TCIN คุณดึงได้จาก HTML ของหน้าค้นหาเองก็ได้ (จะปรากฏใน URL ของสินค้าเป็น /A-XXXXXXXX) หรือดึงจาก JSON ที่ฝังอยู่ใน __TGT_DATA__
ขั้นตอนที่ 4: ขยายสเกลด้วย concurrent requests
from concurrent.futures import ThreadPoolExecutor
import time, random
def fetch_product(tcin):
url = f"https://redsky.target.com/redsky_aggregations/v1/web/pdp_fulfillment_v1?key={API_KEY}&tcin={tcin}&store_id=2148&zip=55401"
time.sleep(random.uniform(2, 5))
resp = cureq.get(url, headers=headers, impersonate="chrome124")
return resp.json()
tcin_list = ["12345678", "23456789", "34567890", "45678901"]
with ThreadPoolExecutor(max_workers=3) as executor:
results = list(executor.map(fetch_product, tcin_list))
อย่าเพิ่ม concurrency แรงเกินไป — 3–5 เธรด พร้อมดีเลย์สุ่ม 2–5 วินาที Target จำกัดอัตราไว้ราว 30–60 requests ต่อนาทีต่อ IP
ข้อควรระวังสำคัญเกี่ยวกับ Redsky API
ก่อนจะเอาไปทำ pipeline จริง มีข้อควรระวังบางอย่าง:
- API key เป็นแบบคงที่ แต่ผูกกับแต่ละ endpoint. Redsky แต่ละ endpoint ใช้คีย์ต่างกัน มันไม่ได้เปลี่ยนบ่อย แต่ Target สามารถเปลี่ยนได้ทุกเมื่อ
- นี่คือ internal API ที่ไม่มีเอกสารอย่างเป็นทางการ. ทีมวิศวกรของ Target เคย ยืนยันว่าตั้งใจเปิดให้เข้าถึงจากภายนอก ซึ่งช่วยลดความเสี่ยงทางกฎหมาย แต่ก็ยังไม่ใช่ public API ที่มี SLA รองรับ
- สินค้าแต่ละตัวเลือกสีหรือขนาดจะมี TCIN แยกกัน. คุณต้อง query แต่ละตัวแยก
- ถ้าขาดเฮดเดอร์
Sec-Fetch-*จะโดนบล็อกทันที. นี่เป็นจุดพลาดที่พบบ่อย — ต้องใส่Sec-Fetch-Site,Sec-Fetch-ModeและSec-Fetch-Destเสมอ
เคล็ดลับการดึงข้อมูล Target.com ในสเกลใหญ่โดยไม่โดนบล็อก
แนวทางเหล่านี้ใช้ได้ในระดับโปรดักชัน ไม่ว่าคุณจะใช้วิธีไหน
หมุน Residential Proxy ไม่ใช่ Datacenter
การใช้งาน Akamai ของ Target จะจับ IP ของดาต้าเซ็นเตอร์ได้ตั้งแต่แรกเห็น Residential proxy เป็นสิ่งจำเป็นสำหรับการดึงข้อมูลต่อเนื่อง ราคามีหลายระดับ — Smartproxy/Decodo เริ่มที่ $4.50/GB Bright Data เริ่มที่ $5.04/GB และลดลงเหลือประมาณ $3–4/GB เมื่อใช้งานในปริมาณมาก
หมุน IP ทุก 50–100 requests หรือทุก request ถ้าพูลพร็อกซีของคุณรองรับ
ปลอม TLS fingerprint ด้วย curl_cffi
นี่คือการเปลี่ยนที่คุ้มค่าที่สุดแบบชัดเจน ใช้แทน requests ได้เลย:
from curl_cffi import requests as cureq
# requests ปกติ — อัตราสำเร็จ 12% บนเว็บที่มีการป้องกัน
# resp = requests.get(url, headers=headers)
# curl_cffi — อัตราสำเร็จ 92%
resp = cureq.get(url, headers=headers, impersonate="chrome124")
curl_cffi (มีดาวบน GitHub มากกว่า 8,200 ดวง) รองรับ Chrome ตั้งแต่ chrome99 ไปจนถึง chrome146 รวมถึง Safari, Edge และเวอร์ชันมือถือด้วย ในโหมด synchronous มัน เร็วกว่า tls_client 20–30%
ตั้งจังหวะการส่ง request และเฮดเดอร์ให้สมจริง
- ดีเลย์แบบสุ่ม: 2–7 วินาทีระหว่าง requests (ไม่ใช่ช่วงตายตัว — ความสุ่มสำคัญมาก)
- หมุน User-Agent: เตรียม pool ของ User-Agent เบราว์เซอร์จริง 5–10 แบบแล้วสลับใช้
- วอร์มอัปเซสชัน: เข้าโฮมเพจ
target.comก่อนยิงไปหน้าสินค้า เพื่อสร้างคุกกี้ - ความสอดคล้องของเฮดเดอร์:
Sec-Ch-Uaต้องตรงกับเวอร์ชันเบราว์เซอร์ที่คุณอ้างว่าใช้Sec-Ch-Ua-Platformต้องตรงกับระบบปฏิบัติการที่อ้างไว้ ถ้าไม่ตรงจะดูหลอกมาก - เก็บ session ให้ต่อเนื่อง: รักษาคุกกี้ไว้ข้าม requests ภายใน session เดียวกัน Scraperly แนะนำ ให้รักษา session ได้ 48 ชั่วโมงด้วย residential proxy ที่หมุน IP
ข้ามโค้ดไปเลย: ดึงข้อมูล Target.com ด้วย Thunderbit (ทางเลือกไม่ต้องเขียนโค้ด)
พูดตามตรง Target.com เป็นหนึ่งในเว็บค้าปลีกที่ดึงข้อมูลด้วยโปรแกรมได้ยากที่สุดเว็บหนึ่งเลย การเรนเดอร์ JavaScript, TLS fingerprinting ของ Akamai, การตรวจจับพร็อกซีดาต้าเซ็นเตอร์, ปัญหาเวอร์ชัน ChromeDriver — มีหลายจุดที่ต้องดูแล ถ้าคุณกำลังเรียน Python นี่เป็นแบบฝึกหัดที่ดีมาก แต่ถ้าคุณต้องใช้ข้อมูลสินค้า Target สำหรับงานจริง ต้นทุนกับผลตอบแทนมักไม่ค่อยคุ้มกัน
สำหรับคนที่ต้องการข้อมูลโดยไม่อยากทำโปรเจกต์วิศวกรรมเอง Thunderbit จะจัดการเรื่องยาก ๆ ให้โดยอัตโนมัติ
Thunderbit จัดการความท้าทายของ Target.com อย่างไร
AI Web Scraper ของ Thunderbit ทำงานในเบราว์เซอร์ของคุณเอง ดังนั้นมันเรนเดอร์ JavaScript ได้ตามธรรมชาติ — ไม่ต้องตั้งค่า Selenium ไม่ต้องคอนฟิก headless browser ไม่ต้องจัดการเวอร์ชัน ChromeDriver ตัวเบราว์เซอร์นั่นแหละคือสคราเปอร์
เวิร์กโฟลว์เป็นแบบนี้:
- ติดตั้ง Thunderbit Chrome Extension แล้วไปที่หน้าสินค้าหรือหน้าค้นหาของ Target
- คลิก “AI Suggest Fields” — Thunderbit จะอ่านหน้าและแนะนำชื่อคอลัมน์ให้ เช่น Product Title, Price, Rating, Image URL ฯลฯ
- คลิก “Scrape” — ดึงข้อมูลออกมาได้ในไม่กี่วินาที จากหน้าที่เรนเดอร์แล้วโดยตรง
ไม่ต้องตั้งค่าพร็อกซี ไม่ต้องปลอม TLS fingerprint ไม่ต้องเจอผลลัพธ์ None
ดึงรายการสินค้าและหน้ารายละเอียดของ Target
เวิร์กโฟลว์หลายหน้าคือจุดที่น่าสนใจที่สุด ดึงหน้าผลการค้นหาของ Target เพื่อได้รายชื่อสินค้า แล้วใช้ Subpage Scraping ให้ระบบเข้าไปยัง URL ของแต่ละสินค้าอัตโนมัติ แล้วเติมข้อมูลจากหน้ารายละเอียดลงในตารางของคุณ — คำอธิบาย รีวิวเต็ม สเปก — โดยไม่ต้องเขียนโค้ดแบ่งหน้าเองหรือคอยจัดการเซสชันเบราว์เซอร์
ส่งออกไปยัง Excel, Google Sheets, Airtable หรือ Notion ได้ตรง ๆ ไม่ต้องเขียน csv.writer ให้ยุ่งยาก และไม่มีปัญหาเรื่อง encoding
ตั้งการดึงข้อมูล Target.com แบบอัตโนมัติซ้ำ ๆ
สำหรับการติดตามราคา หรือเช็กสต็อกเป็นประจำ Thunderbit มี Scheduled Scraper ที่ให้คุณบอกตารางเวลาเป็นภาษาธรรมดาได้เลย เช่น “ทุกวันจันทร์ตอน 9 โมงเช้า” ไม่ต้องตั้ง cron job ไม่ต้องเตรียมเซิร์ฟเวอร์ ไม่ต้องปล่อยให้สคริปต์ Python รันค้างบน VPS ฟีเจอร์นี้เหมาะมากสำหรับทีมอีคอมเมิร์ซที่ติดตาม ราคาคู่แข่ง — ปัจจุบัน 81% ของร้านค้าปลีกในสหรัฐ ใช้การดึงราคาด้วยระบบอัตโนมัติ และ ROI ของ price intelligence เฉลี่ยอยู่ที่ 27:1
ควรใช้วิธีไหนเมื่อดึงข้อมูล Target.com ด้วย Python
นี่คือกรอบตัดสินใจแบบเร็ว:
| สถานการณ์ของคุณ | วิธีที่แนะนำ |
|---|---|
| กำลังเรียน Python, โปรเจกต์เล็ก | วิธีที่ 1: Requests + BS4 (สำหรับข้อมูลสแตติกและ __TGT_DATA__) |
| ต้องการหน้าสินค้าเต็ม ๆ พร้อมราคาและรีวิว | วิธีที่ 2: Selenium / Playwright |
| ต้องดึงข้อมูลสินค้าแบบจำนวนมาก | วิธีที่ 3: Redsky API |
| ต้องการข้อมูลเร็ว ๆ โดยไม่อยากเขียนโค้ด | Thunderbit (ไม่ต้องเขียนโค้ด) |
| ต้องติดตามราคาเป็นประจำ | Thunderbit Scheduled Scraper หรือ Redsky API + cron |
| โปรเจกต์วิจัยครั้งเดียว ทีมไม่ถนัดเทคนิค | Thunderbit — พูดตรง ๆ คือเส้นทางที่เร็วที่สุด |
ถ้าคุณกำลังสร้าง pipeline ข้อมูลระดับโปรดักชัน วิธีที่ 3 (Redsky API) จะให้ทั้งความเร็วและความเสถียรดีที่สุด ถ้าเป็นงานวิจัยครั้งคราว หรือทีมคุณไม่ได้เชี่ยวชาญ Python Thunderbit จะช่วยประหยัดเวลาได้หลายชั่วโมง และถ้าคุณกำลังเรียน web scraping ลำดับ วิธีที่ 1 → วิธีที่ 2 → วิธีที่ 3 คือเส้นทางที่ค่อย ๆ สอนของจริงให้คุณทีละขั้น
ข้อควรคำนึงด้านกฎหมายและจริยธรรมเมื่อดึงข้อมูล Target.com
ควรพูดถึงสั้น ๆ Target robots.txt มีเส้นทาง Disallow ประมาณ 120+ เส้นทาง แต่ที่น่าสังเกตคือไม่ได้บล็อก /p/ (สินค้า) หรือ /c/ (หมวดหมู่) — หน้าสินค้าและหน้าหมวดหมู่จึงอนุญาตให้ crawl ได้อย่างชัดเจน ส่วนหน้ารถเข็น บัญชี และเช็กเอาต์ถูกจำกัด
ข้อกำหนดการใช้งานของ Target ระบุห้ามการเข้าถึงแบบอัตโนมัติ อย่างไรก็ตาม การที่ Redsky API เป็น เปิดให้เข้าถึงจากภายนอกโดยตั้งใจ (Target engineering ยืนยัน) ช่วยลดความเสี่ยงทางกฎหมายสำหรับการเก็บข้อมูลผ่าน API
บรรทัดฐานทางกฎหมายที่ควรรู้:
- hiQ v. LinkedIn (ศาลอุทธรณ์ภาค 9, 2022): การดึงข้อมูลที่เปิดสาธารณะไม่ถือว่าละเมิด CFAA
- Meta v. Bright Data (2024): Meta แพ้คดี — ศาลตัดสินว่าไม่มีการละเมิด CFAA สำหรับการดึงข้อมูลสาธารณะ
ถ้าจะทำการดึงข้อมูลเชิงพาณิชย์ในสเกลใหญ่ ควรปรึกษาที่ปรึกษากฎหมาย สำหรับงานวิจัยตลาด การเปรียบเทียบราคา และโปรเจกต์ส่วนตัวที่ใช้ข้อมูลสาธารณะ คุณอยู่บนพื้นฐานที่ค่อนข้างมั่นคง แต่อย่าลืมเคารพ rate limit และอย่าโหลดเซิร์ฟเวอร์ของ Target หนักเกินไป
สรุปและประเด็นสำคัญ
Target.com สมกับคะแนนความยากของมันจริง ๆ วิธีแบบ naive ที่ใช้ Requests + BeautifulSoup ล้มเหลว เพราะ Target เรนเดอร์ข้อมูลสินค้าผ่าน JavaScript และ Akamai ก็ fingerprint TLS handshake ของคุณตั้งแต่ยังไม่ได้รับ response ด้วยซ้ำ แต่ถ้าใช้วิธีที่ถูกต้อง การดึงข้อมูลก็ตรงไปตรงมาทีเดียว
3 วิธี เรียงตามความน่าเชื่อถือ:
- Redsky API — เร็วและเสถียรที่สุดสำหรับข้อมูลจำนวนมาก ส่งกลับ JSON สะอาด ต้อง reverse-engineer endpoint ผ่าน DevTools ก่อน
- Selenium / Playwright — รับมือการเรนเดอร์ JavaScript ได้ ดึงทุกอย่างบนหน้า แต่ช้ากว่า
- Requests + BeautifulSoup — จำกัดอยู่แค่ HTML สแตติกและ JSON
__TGT_DATA__ที่ฝังอยู่ เร็วแต่ไม่ครบ
ชัยชนะทางเทคนิคที่คุ้มที่สุด:
- ใช้
curl_cffiแทนrequestsปกติ เพื่อเพิ่มความสามารถในการหลบระบบกันบอท 15 เท่า - Residential proxy เป็นสิ่งจำเป็น — IP ของดาต้าเซ็นเตอร์จะถูกจับทันที
- ใส่เฮดเดอร์
Sec-Fetch-*ทุกครั้ง — ถ้าขาดจะโดนบล็อกทันที - วอร์มอัปเซสชันด้วยการเข้าโฮมเพจก่อน ช่วยเพิ่มอัตราสำเร็จได้มาก
และถ้า Python ไม่คุ้มกับความปวดหัวสำหรับงานของคุณ Thunderbit Chrome Extension จะจัดการการเรนเดอร์ JavaScript มาตรการกันบอท และการส่งออกข้อมูลให้อัตโนมัติ ลองใช้ แผนฟรี ดูว่าในไม่กี่นาทีมันให้ผลลัพธ์ที่คุณต้องการได้ไหม แทนที่จะเสียเวลาหลายชั่วโมง
ถ้าอยากได้ไกด์ดึงข้อมูลและเคล็ดลับการแยกข้อมูลเพิ่มเติม ลองดู Thunderbit blog หรือ ช่อง YouTube ของเรา
คำถามที่พบบ่อย
ฉันสามารถดึงข้อมูล Target.com ด้วยแค่ Python Requests และ BeautifulSoup ได้ไหม?
ได้บางส่วน คุณสามารถดึงชื่อสินค้า URL และ JSON บางส่วนที่ฝังอยู่ในแท็กสคริปต์ __TGT_DATA__ บนหน้าสินค้าได้ แต่ราคา คะแนน รีวิว และความพร้อมจำหน่ายบนหน้าผลการค้นหาถูกเรนเดอร์ด้วย JavaScript จึงไม่ปรากฏใน HTTP request แบบสแตติก ถ้าต้องการข้อมูลครบ ใช้ Selenium/Playwright หรือ Redsky API จะดีกว่า
ทำไมสคราเปอร์ Target.com ของฉันถึงคืนค่า None สำหรับราคา?
Target โหลดข้อมูลราคาผ่าน JavaScript หลังจากหน้าโหลดครั้งแรก เมื่อคุณใช้ requests.get() คุณจะได้รับ HTML shell ที่ยังไม่ถูกเรนเดอร์ — ก่อนที่ JavaScript จะทำงานและฉีดข้อมูลสินค้าเข้า DOM จริง ๆ องค์ประกอบราคาจึงไม่มีอยู่ใน response เลย ใช้เบราว์เซอร์แบบ headless (Selenium หรือ Playwright) ที่เรนเดอร์ JavaScript เรียก Redsky API โดยตรงเพื่อเอา JSON หรือใช้เครื่องมืออย่าง Thunderbit ที่ดึงข้อมูลจากหน้าเบราว์เซอร์ที่เรนเดอร์แล้ว
การดึงข้อมูล Target.com ผิดกฎหมายไหม?
โดยทั่วไป การดึงข้อมูลที่เปิดให้สาธารณะถือว่าอนุญาตตามบรรทัดฐานคดีในสหรัฐปัจจุบัน (hiQ v. LinkedIn, Meta v. Bright Data) robots.txt ของ Target อนุญาตให้ crawl หน้าสินค้าและหน้าหมวดหมู่ อย่างไรก็ตาม ข้อกำหนดการใช้งานของ Target ห้ามการเข้าถึงแบบอัตโนมัติ ดังนั้นจึงมีพื้นที่สีเทาอยู่บ้าง ถ้าใช้ข้อมูลสาธารณะเพื่อวิจัยตลาดหรือเปรียบเทียบราคา คุณยืนอยู่บนพื้นฐานที่พอสมเหตุสมผล แต่ถ้าจะทำเชิงพาณิชย์ในสเกลใหญ่ ควรปรึกษาทนาย
Redsky API ของ Target คืออะไร และเข้าถึงยังไง?
Redsky คือ API ภายในของ Target ที่ขับเคลื่อนข้อมูลสินค้าบนหน้าเว็บ มันไม่ใช่ public API ที่มีเอกสารและให้สมัคร API key แบบทั่วไป แต่มันคือแบ็กเอนด์ที่แอป React เรียกใช้เพื่อเรนเดอร์หน้าสินค้า คุณสามารถค้นหา endpoint ได้ด้วยการเปิด Chrome DevTools กรองแท็บ Network ด้วย XHR/Fetch แล้วมองหาคำขอไปที่ redsky.target.com API key จะฝังอยู่ใน URL ของ request เป็น query parameter ทีมวิศวกรของ Target ยืนยันแล้วว่า API นี้ตั้งใจเปิดให้เข้าถึงจากภายนอก
จะหลีกเลี่ยงการโดนบล็อกตอนดึงข้อมูล Target.com ได้อย่างไร?
การเปลี่ยนที่ได้ผลมากที่สุดเพียงอย่างเดียวคือใช้ curl_cffi แทน requests ของ Python ปกติ เพื่อปลอม TLS fingerprint ของเบราว์เซอร์ — แค่นี้อัตราสำเร็จก็เพิ่มจาก 12% เป็น 92% แล้ว นอกเหนือจากนั้น: ใช้ residential proxy ไม่ใช่ datacenter, หมุน User-Agent, ใส่ดีเลย์สุ่ม 2–7 วินาทีระหว่าง requests, ใส่เฮดเดอร์ Sec-Fetch-* ครบทุกตัว และวอร์มอัป session ด้วยการเข้าโฮมเพจก่อน หรือถ้าอยากง่ายกว่านั้น ใช้เครื่องมืออย่าง Thunderbit ที่จัดการมาตรการกันบอทให้อัตโนมัติโดยไม่ต้องตั้งค่าอะไรเลย
เรียนรู้เพิ่มเติม
