Cara Mengumpulkan Data Google Shopping dengan Proxy

Mengumpulkan data dari Google Shopping berarti mengambil data produk terstruktur (judul, harga, penjual, rating, dan catatan pengiriman) dari hasil belanja Google dalam skala besar. Karena hasil tersebut sangat dilindungi dan dilokalkan, melakukannya secara andal memerlukan IP rotating dan geo-targeting yang tepat, bukan satu scraper pada satu koneksi.

Panduan ini berfokus pada kode. Panduan ini membahas request geo-targeting, perutean melalui proxy khusus negara, parsing kartu produk yang sengaja disamarkan oleh Google, pagination, retry dan backoff saat terkena rate limit, fallback headless browser dengan penanganan dialog persetujuan, model data yang rapi dengan ekspor CSV, pelacak riwayat harga, dan jadwal monitoring. Panduan ini juga membahas secara jujur realitas anti-bot, pertukaran antara scraper mandiri dan SERP API berbayar, serta batasan hukumnya.

DataImpulse adalah penyedia proxy beretika yang menawarkan lebih dari 90 juta alamat IP residential, mobile, dan datacenter di 195 negara. DataImpulse menggunakan model pay-as-you-go mulai dari 1 dolar per GB dengan lalu lintas yang tidak kedaluwarsa, serta digunakan untuk web scraping, verifikasi iklan, monitoring harga, riset pasar, dan pengelolaan banyak akun.

Data apa yang dapat Anda kumpulkan dari Google Shopping?

Google Shopping menampilkan daftar produk dengan beberapa field terstruktur yang berguna untuk riset harga dan pasar. Setiap hasil biasanya memuat serangkaian atribut konsisten yang dapat Anda ekstrak dan normalkan menjadi baris.

• Detail produk: judul, cuplikan deskripsi, merek, model, dan URL gambar produk.
• Harga: harga yang tercantum, mata uang, dan terkadang rentang harga dari berbagai penjual.
• Penjual: nama pedagang dan, pada halaman detail produk, daftar penjual pesaing yang menawarkan barang yang sama.
• Rating dan ulasan: rating bintang gabungan dan jumlah ulasan jika tersedia.
• Ketersediaan dan pengiriman: status stok dan catatan pengiriman yang berbeda menurut wilayah.

Field yang tepat berubah setiap kali Google memperbarui tata letaknya, sehingga parser harus dapat menangani nilai yang hilang dan markup yang berubah. Perlakukan setiap field sebagai opsional dan validasi tipe setelah ekstraksi, alih-alih mengasumsikan rating atau penjual selalu tersedia. Karena produk yang sama dapat muncul dengan harga berbeda di negara yang berbeda, rancang skema Anda berdasarkan kunci (produk, negara, timestamp) sejak awal, bukan menambahkan lokasi geografis belakangan.

Bagaimana cara mengirim request geo-targeting ke Google Shopping?

Anda mengirim request geo-targeting dengan mengakses endpoint pencarian Google menggunakan flag tab belanja dan parameter locale, lalu mengirim sinyal IP dan parameter yang sama seperti pembeli sungguhan. Dua parameter yang paling penting adalah gl (negara, misalnya gl=de untuk Jerman) dan hl (bahasa antarmuka, misalnya hl=de). Parameter ketiga yang berguna adalah istilah bergaya location yang Anda masukkan ke konteks query, tetapi gl ditambah exit IP yang sesuai melakukan sebagian besar pekerjaan.

Menetapkan parameter saja tidak cukup, karena Google juga membaca IP request untuk menentukan harga dan penjual yang ditampilkan. Request minimal di bawah mengirim header yang realistis dan pasangan locale. Request ini sengaja tanpa proxy agar Anda dapat melihat pemanggilan dasar sebelum menambahkan lapisan IP.

import requests

def build_params(query, country="us", lang="en", start=0):
    return {
        "q": query,
        "tbm": "shop",   # shopping vertical
        "gl": country,    # country bias, e.g. de, gb, fr
        "hl": lang,       # interface language
        "num": 40,        # results per page (soft cap)
        "start": start,   # pagination offset
    }

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/124.0 Safari/537.36"
    ),
    "Accept-Language": "en-US,en;q=0.9",
}

resp = requests.get(
    "https://www.google.com/search",
    params=build_params("wireless headphones", country="us", lang="en"),
    headers=HEADERS,
    timeout=30,
)
print(resp.status_code, len(resp.text))

Pertahankan Accept-Language agar selaras dengan hl. Halaman harga Jerman yang diminta dengan header bahasa Inggris tidak selaras, terlihat tidak alami, dan dapat mengembalikan mata uang yang salah. Saat Anda meningkatkan skala, fungsi dasar ini menjadi satu-satunya tempat penetapan locale sehingga setiap pemanggilan lanjutan tetap konsisten.

Bagaimana cara merutekan request melalui proxy country-targeted?

Anda merutekan melalui proxy country-targeted dengan mengarahkan requests ke satu gateway dan menyandikan negara target dalam username proxy. Dengan DataImpulse, gateway-nya adalah gw.dataimpulse.com:823, dan menambahkan __cr.us atau __cr.de pada username Anda memilih negara exit. Country targeting sudah termasuk dalam harga dasar, sedangkan targeting negara bagian, kota, ZIP, dan ASN adalah add-on berbayar. Jika autentikasi proxy masih baru bagi Anda, panduan kami tentang autentikasi proxy membahas mekanisme username dan password secara mendalam.

import requests

USER = "your_login"
PASS = "your_password"
GATEWAY = "gw.dataimpulse.com:823"

def proxy_for(country):
    # __cr. pins the exit IP to that country
    cred = f"{USER}__cr.{country}:{PASS}"
    url = f"http://{cred}@{GATEWAY}"
    return {"http": url, "https": url}

resp = requests.get(
    "https://www.google.com/search",
    params=build_params("wireless headphones", country="de", lang="de"),
    headers=HEADERS,
    proxies=proxy_for("de"),
    timeout=30,
)
print(resp.status_code, len(resp.text))

Disiplin pentingnya adalah mengganti negara proxy dan pasangan gl/hl secara bersamaan. Untuk membuat perbandingan harga lintas pasar, lakukan loop pada daftar negara dan pertahankan exit IP serta locale tetap selaras agar setiap response mencerminkan satu lokasi pembeli yang konsisten.

MARKETS = [
    {"country": "us", "lang": "en"},
    {"country": "de", "lang": "de"},
    {"country": "gb", "lang": "en"},
    {"country": "fr", "lang": "fr"},
]

def fetch_market(query, market):
    c, lang = market["country"], market["lang"]
    return requests.get(
        "https://www.google.com/search",
        params=build_params(query, country=c, lang=lang),
        headers={**HEADERS, "Accept-Language": f"{lang};q=0.9"},
        proxies=proxy_for(c),
        timeout=30,
    )

for m in MARKETS:
    r = fetch_market("wireless headphones", m)
    print(m["country"], r.status_code, len(r.text))

DataImpulse menyediakan lapisan IP, bukan layanan scraping terkelola, sehingga scraper itu sendiri menjadi tanggung jawab Anda. Proxy residential rotating biasanya cocok di sini karena berasal dari perangkat konsumen asli; proxy datacenter lebih murah tetapi lebih mudah ditandai, dan proxy mobile menyediakan IP tingkat operator untuk target yang paling sulit.

Bagaimana cara melakukan parsing kartu produk Google Shopping?

Anda melakukan parsing kartu produk dengan library HTML yang toleran dan berpatokan pada pola teks yang stabil, bukan selector mendalam yang rapuh, karena nama class Google disamarkan dan sering berganti. Selector apa pun yang Anda salin dari dev tools browser hari ini dapat rusak dalam beberapa minggu, jadi buat parser yang dapat mengalami penurunan fungsi secara anggun, bukan crash saat tata letak berubah.

Pendekatan yang tangguh membaca setiap kartu kandidat, mengambil judul dan gambar dari struktur tag, serta mengekstrak harga dengan regular expression yang mengenali mata uang. Selector di bawah adalah contoh realistis, bukan jaminan; bersiaplah memperbaruinya dan pertahankan regex sebagai fallback yang andal.

from bs4 import BeautifulSoup
import re

# Currency-aware price matcher: symbol optional, thousands and decimals tolerated.
PRICE_RE = re.compile(r"(?:[$€£]|USD|EUR|GBP)\s?\d[\d.,]*")

def parse_cards(html):
    soup = BeautifulSoup(html, "html.parser")
    rows = []
    # These class names ROTATE; treat them as hints, keep the fallbacks.
    candidates = soup.select("div.sh-dgr__content, div.sh-dlr__list-result, div[data-docid]")
    if not candidates:
        candidates = soup.find_all("div")  # last-resort sweep
    for card in candidates:
        text = card.get_text(" ", strip=True)
        price_match = PRICE_RE.search(text)
        if not price_match or len(text) > 400:
            continue
        img = card.find("img")
        link = card.find("a", href=True)
        rows.append({
            "title": _first_text(card, ["h3", "h4"]),
            "price_raw": price_match.group(0),
            "image": img.get("src") if img else None,
            "url": link["href"] if link else None,
        })
    return rows

def _first_text(card, tags):
    for t in tags:
        el = card.find(t)
        if el and el.get_text(strip=True):
            return el.get_text(strip=True)
    return None

CURRENCY = {"$": "USD", "€": "EUR", "£": "GBP"}

def normalize_price(raw):
    if not raw:
        return None, None
    symbol = next((s for s in CURRENCY if s in raw), None)
    code = CURRENCY.get(symbol, "USD")
    digits = re.sub(r"[^\d.,]", "", raw).replace(",", "")
    try:
        return float(digits), code
    except ValueError:
        return None, code

Karena markup yang disamarkan adalah hal lazim di sini, sebagian tim memilih DOM hasil rendering. Untuk pembahasan lebih luas mengenai pertukaran parsing HTML statis versus halaman hasil rendering, lihat panduan kami tentang scraping halaman web dinamis.

Bagaimana cara melakukan pagination dan backoff saat Google mengembalikan 429?

Anda melakukan pagination dengan memajukan offset start secara bertahap sesuai ukuran halaman, dan menangani rate limit dengan memperlakukan HTTP 429 (serta response kosong atau CAPTCHA) sebagai sinyal untuk menunggu dan melakukan retry melalui IP baru. Google membatasi request otomatis berulang secara agresif, sehingga pagination dan backoff harus berada dalam loop yang sama.

Telusuri halaman hingga request tidak mengembalikan kartu atau Anda mencapai batas halaman. Putar exit IP di antara halaman dengan membaca ulang dict proxy, lalu deteksi pemblokiran lunak dengan memeriksa penanda persetujuan atau CAPTCHA di body, bukan hanya mempercayai status code.

BLOCK_MARKERS = ("unusual traffic", "/sorry/", "consent.google", "captcha")

def is_blocked(resp):
    if resp.status_code in (429, 503):
        return True
    body = resp.text.lower()
    return any(m in body for m in BLOCK_MARKERS)

def paginate(query, market, max_pages=5, page_size=40):
    all_rows = []
    for page in range(max_pages):
        params = build_params(query, market["country"], market["lang"],
                              start=page * page_size)
        resp = get_with_retry(
            "https://www.google.com/search",
            params=params, proxies=proxy_for(market["country"]),
        )
        if resp is None:
            break
        rows = parse_cards(resp.text)
        if not rows:
            break  # no more results
        all_rows.extend(rows)
    return all_rows

Helper retry di bawah menggunakan exponential backoff dengan jitter, yang menyebarkan retry agar lonjakan worker yang diblokir tidak semuanya melakukan retry pada saat yang sama. Setiap percobaan mengambil kembali dict proxy, sehingga pool rotating memberikan IP baru pada percobaan berikutnya.

import time, random

def get_with_retry(url, params, proxies, max_attempts=4):
    for attempt in range(max_attempts):
        try:
            resp = requests.get(url, params=params, headers=HEADERS,
                                proxies=proxies, timeout=30)
        except requests.RequestException:
            resp = None
        if resp is not None and not is_blocked(resp):
            return resp
        # exponential backoff: 2, 4, 8 seconds, plus jitter
        wait = (2 ** (attempt + 1)) + random.uniform(0, 1.5)
        time.sleep(wait)
    return None  # exhausted; caller decides what to do

Jaga laju request tetap wajar bahkan ketika retry berhasil. Jeda dasar yang wajar di antara halaman, dikombinasikan dengan rotation, lebih baik untuk stabilitas jangka panjang daripada menghantam layanan dan mengandalkan retry. Catatan kami tentang praktik terbaik web scraping membahas pengaturan tempo dan kebersihan header secara lebih rinci.

Bagaimana cara merender halaman yang diblokir dengan headless browser?

Saat request HTTP biasa terus mengenai dinding persetujuan atau konten hasil rendering JavaScript, gunakan headless browser yang menjalankan halaman seperti klien sungguhan dan menutup dialog persetujuan sebelum membaca DOM. Playwright cocok digunakan karena mendukung proxy per konteks dan penantian yang andal.

Skrip di bawah menjalankan Chromium melalui proxy DataImpulse country-targeted, menangani dialog cookie atau persetujuan yang biasanya ditampilkan locale Eropa, menunggu konten, dan mengembalikan HTML hasil rendering sehingga Anda dapat memasukkannya ke fungsi parse_cards.

from playwright.sync_api import sync_playwright

def render_shopping(query, country="de", lang="de"):
    cred_user = f"{USER}__cr.{country}"
    params = f"?q={query.replace(' ', '+')}&tbm=shop&gl={country}&hl={lang}"
    url = "https://www.google.com/search" + params
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        context = browser.new_context(
            proxy={
                "server": "http://gw.dataimpulse.com:823",
                "username": cred_user,
                "password": PASS,
            },
            locale=f"{lang}-{country.upper()}",
            user_agent=HEADERS["User-Agent"],
        )
        page = context.new_page()
        page.goto(url, wait_until="domcontentloaded", timeout=45000)
        _dismiss_consent(page)
        page.wait_for_timeout(2000)
        html = page.content()
        browser.close()
        return html

def _dismiss_consent(page):
    # Consent dialogs vary by locale; try a few common accept buttons.
    for label in ("Accept all", "Alle akzeptieren", "Tout accepter",
                  "I agree", "Accept"):
        try:
            btn = page.get_by_role("button", name=label)
            if btn.count() > 0:
                btn.first.click(timeout=3000)
                page.wait_for_timeout(1000)
                return
        except Exception:
            continue

Headless browser lebih berat pada CPU dan memori dibandingkan request mentah, jadi gunakan sebagai fallback terarah untuk halaman yang benar-benar memerlukan rendering, bukan sebagai jalur default. Banyak tim menjalankan HTTP langsung demi kecepatan dan hanya beralih ke Playwright ketika is_blocked terus terpanggil. Jika stack Anda JavaScript, bukan Python, pola yang sama berlaku untuk Puppeteer; lihat web scraping dengan JavaScript.

Bagaimana cara menyusun dan mengekspor data yang dikumpulkan?

Anda menyusun data berdasarkan record stabil yang selalu mencakup pasar dan timestamp pengambilan, lalu mengekspornya ke CSV agar output mudah dibandingkan, dimuat ke spreadsheet, atau dimasukkan ke warehouse. Dataclass menyediakan type hint dan satu definisi baris yang jelas.

from dataclasses import dataclass, asdict, field
from datetime import datetime, timezone
import csv

@dataclass
class Offer:
    query: str
    country: str
    title: str | None
    price: float | None
    currency: str | None
    seller: str | None = None
    url: str | None = None
    captured_at: str = field(
        default_factory=lambda: datetime.now(timezone.utc).isoformat()
    )

def to_offers(rows, query, country):
    offers = []
    for r in rows:
        price, currency = normalize_price(r.get("price_raw"))
        offers.append(Offer(
            query=query, country=country, title=r.get("title"),
            price=price, currency=currency, url=r.get("url"),
        ))
    return offers

Menulis CSV kemudian cukup dengan mengekspor field dataclass. Mode append dengan header guard memungkinkan job terjadwal menambah satu file dari waktu ke waktu tanpa menulis ulang.

import os

def export_csv(offers, path="google_shopping.csv"):
    if not offers:
        return
    fieldnames = list(asdict(offers[0]).keys())
    write_header = not os.path.exists(path)
    with open(path, "a", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        if write_header:
            writer.writeheader()
        for o in offers:
            writer.writerow(asdict(o))

Menyimpan negara dan timestamp pada setiap baris memungkinkan Anda menjawab pertanyaan seperti pasar mana yang paling murah untuk SKU hari ini, atau bagaimana harga bergerak minggu ini. Kunci geografis dan waktu tersebut menjadi dasar pelacak riwayat harga di bagian berikutnya.

Bagaimana cara melacak riwayat harga Google Shopping dari waktu ke waktu?

Anda melacak riwayat harga dengan melakukan upsert setiap pengamatan ke database kecil berkunci produk, negara, dan hari, sehingga menjalankan ulang scraper memperbarui baris hari ini alih-alih menduplikasinya sambil mempertahankan hari-hari sebelumnya. SQLite cukup untuk jutaan baris dan tidak memerlukan server, sehingga job monitoring tetap mandiri.

Skema di bawah menggunakan unique key gabungan dan upsert ON CONFLICT. Menjalankan scraper dua kali dalam satu hari menimpa harga terbaru untuk (produk, negara, hari) tersebut; menjalankannya lintas hari membangun deret waktu yang dapat Anda buat grafiknya nanti.

import sqlite3

DDL = """
CREATE TABLE IF NOT EXISTS price_history (
    product   TEXT NOT NULL,
    country   TEXT NOT NULL,
    day       TEXT NOT NULL,
    price     REAL,
    currency  TEXT,
    seller    TEXT,
    captured_at TEXT,
    PRIMARY KEY (product, country, day)
);
"""

def init_db(path="prices.db"):
    conn = sqlite3.connect(path)
    conn.execute(DDL)
    conn.commit()
    return conn

def upsert_offers(conn, offers):
    sql = """
    INSERT INTO price_history
        (product, country, day, price, currency, seller, captured_at)
    VALUES (?, ?, ?, ?, ?, ?, ?)
    ON CONFLICT(product, country, day) DO UPDATE SET
        price=excluded.price,
        currency=excluded.currency,
        seller=excluded.seller,
        captured_at=excluded.captured_at;
    """
    for o in offers:
        day = o.captured_at[:10]  # YYYY-MM-DD
        conn.execute(sql, (o.title, o.country, day, o.price,
                           o.currency, o.seller, o.captured_at))
    conn.commit()

def price_trend(conn, product, country, days=14):
    cur = conn.execute(
        """SELECT day, price, currency FROM price_history
           WHERE product = ? AND country = ?
           ORDER BY day DESC LIMIT ?""",
        (product, country, days),
    )
    return cur.fetchall()

Mencocokkan judul lintas hari adalah bagian yang sulit dalam praktik, karena judul Google sedikit berbeda di antara pengambilan. Untuk watchlist kecil, petakan judul mentah ke id produk kanonis yang Anda kontrol sebelum melakukan upsert, alih-alih mempercayai judul hasil scraping sebagai kunci stabil.

Bagaimana cara menjadwalkan monitoring harga berkelanjutan?

Anda menjadwalkan monitoring dengan membungkus langkah pengambilan, parsing, dan penyimpanan ke dalam satu entry point lalu menjalankannya dalam jadwal tetap dengan cron, sehingga harga diperbarui otomatis tanpa menjalankan secara manual. Eksekusi sekali sehari adalah default yang masuk akal untuk pelacakan harga; eksekusi lebih sering meningkatkan biaya dan risiko pemblokiran tanpa banyak tambahan sinyal untuk sebagian besar katalog.

# run_monitor.py
def run_once(queries):
    conn = init_db()
    for query in queries:
        for market in MARKETS:
            rows = paginate(query, market, max_pages=3)
            offers = to_offers(rows, query, market["country"])
            export_csv(offers)
            upsert_offers(conn, offers)
            print(f"{query} / {market['country']}: {len(offers)} offers")
    conn.close()

if __name__ == "__main__":
    WATCHLIST = ["wireless headphones", "mechanical keyboard"]
    run_once(WATCHLIST)

Kemudian daftarkan dengan cron. Entri di bawah menjalankan monitor setiap hari pada pukul 06:15 dan mencatat output untuk debugging, yang penting karena scraper terjadwal dapat gagal tanpa terlihat.

# crontab -e
# minute hour day month weekday  command
15 6 * * * cd /opt/shopping && /usr/bin/python3 run_monitor.py >> monitor.log 2>&1

Tambahkan jitter ringan di dalam job (sleep acak selama beberapa menit pada awal proses) agar request tidak mengenai Google pada detik waktu yang sama setiap hari. Putar negara exit dan atur tempo request seperti dibahas sebelumnya, lalu pantau log untuk kenaikan tingkat pemblokiran, yang merupakan tanda paling awal bahwa Google telah mengubah pertahanannya atau pola Anda menjadi terlalu teratur.

Pendekatan pengumpulan mana yang sebaiknya Anda pilih: DIY, endpoint tersembunyi, SERP API, atau headless?

Pilih berdasarkan seberapa besar kerapuhan dan pekerjaan engineering yang bersedia Anda tanggung dibandingkan biaya per request yang bersedia Anda bayar. Tidak ada satu jawaban yang benar; pertukaran yang sebenarnya adalah kontrol dan biaya melawan beban maintenance dan paparan anti-bot.

Realitas anti-bot: Google secara aktif melindungi hasil ini dengan rate limiting, CAPTCHA, dinding persetujuan, markup obfuscate rotating, dan sinyal perilaku. Setiap scraper mandiri akan rusak secara berkala dan memerlukan maintenance berkelanjutan. Proxy dan backoff mengurangi pemblokiran; keduanya tidak menghilangkannya. Siapa pun yang menjanjikan scraper Google yang permanen tidak dapat diblokir sedang menjual klaim berlebihan.

SERP API versus DIY: SERP API pihak ketiga mengembalikan hasil belanja yang sudah melalui parsing sebagai JSON dan menangani pekerjaan parsing serta pembukaan blokir untuk Anda, dengan harga per request, vendor lock-in, dan kontrol yang lebih kecil atas apa yang diambil. Scraper mandiri pada proxy jauh lebih murah per request dan memberi Anda kontrol penuh, tetapi parser, retry, dan maintenance saat Google berubah menjadi tanggung jawab Anda. Agar jelas mengenai posisi DataImpulse: DataImpulse adalah lapisan proxy di bawah setiap pendekatan DIY ini, bukan SERP API dan bukan layanan scraping terkelola. Jika Anda tidak ingin melakukan pekerjaan parsing, SERP API adalah rekomendasi yang jujur; jika Anda menginginkan biaya rendah dan kontrol serta dapat memelihara scraper, DIY pada proxy rotating lebih ekonomis. Endpoint JSON tersembunyi dapat lebih murah lagi, tetapi paling rapuh karena Google dapat mengubah atau menghapusnya tanpa pemberitahuan.

Apakah mengumpulkan data Google Shopping legal dan etis?

Scraping data produk yang terlihat publik umumnya dianggap berisiko lebih rendah daripada mengakses konten privat atau berpagar, tetapi tetap ada aturan yang berlaku, dan ini bukan nasihat hukum. Harga dan daftar di Google Shopping bersifat publik, tetapi cara Anda mengumpulkan dan menggunakannya tetap penting, dan Anda sebaiknya mengonfirmasi kasus spesifik Anda dengan penasihat hukum yang kompeten.

• Ketentuan layanan: akses otomatis dapat bertentangan dengan ketentuan Google, yang merupakan masalah kontraktual terpisah dari hak cipta atau hukum akses komputer.
• Data pribadi: daftar produk biasanya bukan data pribadi, tetapi hindari mengumpulkan nama pengulas atau pengenal lain, dan patuhi GDPR jika berlaku.
• Laju dan beban: jaga volume request tetap wajar agar Anda tidak menurunkan kualitas layanan yang Anda query.
• Penggunaan data: menggunakan ulang gambar atau deskripsi berhak cipta secara menyeluruh membawa risiko lebih besar daripada menganalisis harga sebagai fakta.

Dalam pengumpulan data, etika dimulai dari IP yang Anda gunakan. DataImpulse memperoleh IP dari pengguna yang memberikan persetujuan dan menerima kompensasi, selaras dengan GDPR, serta menawarkan perjanjian pemrosesan data yang mendukung pipeline yang dapat dipertanggungjawabkan. Untuk pembahasan lebih lengkap tentang persetujuan, sumber, dan praktik bertanggung jawab, lihat panduan kami tentang web scraping yang etis. Gabungkan sumber IP yang etis dengan tempo yang wajar dan penggunaan data yang terbatas serta faktual untuk menjaga risiko hukum maupun reputasi tetap rendah.

Pertanyaan yang sering diajukan

Panduan terkait

• Cara Mengumpulkan Data Google Trends
• Cara Mengumpulkan Data Daftar Hotel
• Mengumpulkan Data Halaman Web Dinamis

Mulai mengumpulkan data Google Shopping dengan proxy andal

Jika Anda siap mengumpulkan data Google Shopping di berbagai pasar, DataImpulse menyediakan IP residential, mobile, dan datacenter rotating serta sticky dengan country targeting yang sudah termasuk, mulai dari 1 dolar per GB. Buat akun dan rutekan scraper pertama Anda melalui pool IP yang bersih.