Proxy ile Amazon Anahtar Kelime Sıralama Takibi: Geliştirici Rehberi

Proxy ile Amazon Anahtar Kelime Sıralama Takibi: Temeller

Yasal uyarı: Bu rehber yalnızca herkese açık arama verilerinin toplanmasını ele alır. ABD'de Bilgisayar Dolandırıcılığı ve İstismar Yasası (CFAA) ve AB'de GDPR kapsamında, erişim izniniz olmayan sistemlere izinsiz girmek veya kişisel verileri toplamak yasa dışı olabilir. Yalnızca kendi ASIN'lerinizi ve herkese açık listeleri takip edin, hız sınırlarına uyun ve mümkün olduğunda Amazon'un resmi SP-API'sini kullanın.

Proxy ile Amazon anahtar kelime sıralama takibi, Amazon satıcıları ve pazar yeri SEO geliştiricileri için kritik bir yetkinliktir. Amazon'un arama motoru Google'dan farklı çalışır; sıralamalar relevans ve satış hızı tarafından belirlenir. Bu nedenle bir ASIN'in belirli bir anahtar kelime için organik konumunu, pazar yerine ve zamana göre takip etmek, listing optimizasyonu ve reklam stratejisi için vazgeçilmezdir.

Bu rehberde, Amazon SERP'lerini residential proxy kullanarak kazıyacak, organik sıralamayı hesaplayacak ve pozisyon geçmişini saklayacak tam bir Python pipeline'ı kuracağız. SERP takibi kullanım senaryosuyla uyumlu olarak, ProxyHat residential proxy altyapısını kullanacağız.

Amazon Araması Neden Kendi Başına Bir SERP'tir?

Amazon'un arama sonuçları sayfası (SERP), Google'ınkiyle benzer bir DOM yapısına sahip olsa da, sıralama mantığı tamamen farklıdır. Amazon'un A9 (artık A10 olarak bilinen) algoritması şu faktörleri ağırlıklı olarak kullanır:

• Satış hızı (sales velocity): Yakın geçmişteki dönüşüm oranı ve satış hacmi.
• Relevans sinyalleri: Başlık, bullet points, arka plan anahtar kelimeleri, kategori eşleşmesi.
• Stok durumu ve fiyat rekabetçiliği: Stokta olmayan ürünler sıralamada düşer.
• İnceleme metrikleri: Yıldız puanı ve yorum sayısı.

Sonuç olarak, bir ASIN'in belirli bir anahtar kelime için organik sıralaması gün gün değişebilir. Satıcılar bu değişimi izlemek için bir amazon anahtar kelime sıralama takip aracı geliştirmek zorundadır. Bu araç, her anahtar kelime için SERP'yi periyodik olarak çekmeli, hedef ASIN'in konumunu bulmalı ve Sponsored (reklam) yerleşimlerini organik sonuçlardan ayırmalıdır.

Sonuç Sayfasını Parse Etmek

Amazon arama sonuçları sayfasındaki her ürün kartı data-component-type="s-search-result" özniteliğine sahip bir <div> içindedir. Her kartın içinde:

• data-asin özniteliği ürünün ASIN'ini içerir.
• Kart içindeki Sponsored etiketi, sonucun ödemeli reklam olduğunu belirtir.
• Organik pozisyon, Sponsored olmayan kartların DOM sırasına göre 1'den başlayarak numaralandırılır.

İşte HTML yapısının basitleştirilmiş bir örneği:

<div data-component-type="s-search-result" data-asin="B08N5WRWNW">
  <span class="a-color-secondary">Sponsored</span>
  <!-- reklam içeriği -->
</div>
<div data-component-type="s-search-result" data-asin="B07XJ8C8F5">
  <!-- organik sonuç -->
</div>

Organik pozisyon hesaplarken, Sponsored kartlarını atlayarak yalnızca organik sonuçları 1, 2, 3... diye numaralandırmanız gerekir. Aksi takdirde, bir reklamın üstte görünmesi sıralamanızı yanlış ölçmenize yol açar.

Neden Residential Proxy ve Coğrafi Hedefleme Gerekli?

Amazon, pazar yerine göre sonuçları lokalize eder. amazon.com ile amazon.de aynı anahtar kelime için tamamen farklı sonuçlar döndürür. Ayrıca Amazon, şüpheli trafiği tespit etmek için:

• IP coğrafi konumu ile istek başlığındaki locale bilgisini karşılaştırır.
• Tek bir IP'den gelen yüksek hacimli istekleri rate-limitler (genellikle dakikada ~80-120 istek sonrası 429 veya CAPTCHA).
• Datacenter IP'lerini bot trafiği olarak işaretleyip CAPTCHA gösterir.

Bu nedenle amazon serp scraping için residential proxy kullanmak neredeyse zorunludur. ProxyHat'ın residential ağı, gerçek ISP IP'leri sunduğu için Amazon'un datacenter tespitinden kaçınır. ProxyHat gateway'inde ülke hedeflemesi kullanıcı adında yapılır:

• user-country-US → amazon.com için ABD IP'leri
• user-country-DE → amazon.de için Almanya IP'leri
• user-country-GB → amazon.co.uk için İngiltere IP'leri

Pagination yaparken (sayfa 1-5 gibi), aynı IP'den kalıcı kalmak için -session- bayrağı kullanılır. Bu, oturum bazlı yapışkan (sticky) IP sağlar ve Amazon'un sayfalar arası tutarlılık kontrolünü geçmenize yardımcı olur. ProxyHat lokasyonlar sayfasından desteklenen tüm ülkeleri görebilirsiniz.

Python ile Amazon Sıralama Takibi: curl_cffi Örneği

Aşağıdaki örnek, curl_cffi kütüphanesini kullanarak Amazon arama sonuçlarını ProxyHat residential proxy üzerinden çeker, hedef ASIN'in organik pozisyonunu hesaplar ve sonuçları bir CSV dosyasına kaydeder.

import csv
import re
import time
import logging
from datetime import datetime, timezone
from curl_cffi import requests
from bs4 import BeautifulSoup

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger(__name__)

# ProxyHat bağlantı bilgileri
PROXY_USER = "user-country-US-session-rank001"
PROXY_PASS = "your_password"
PROXY_URL = f"http://{PROXY_USER}:{PROXY_PASS}@gate.proxyhat.com:8080"

AMAZON_BASE = "https://www.amazon.com"
TARGET_ASIN = "B07XJ8C8F5"
KEYWORD = "wireless earbuds"
MAX_PAGES = 5

HEADERS = {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
}

def build_search_url(keyword: str, page: int) -> str:
    """Amazon arama URL'sini sayfa numarasıyla oluşturur."""
    return f"{AMAZON_BASE}/s?k={requests.utils.quote(keyword)}&page={page}"

def fetch_page(url: str, retries: int = 3) -> str | None:
    """Proxy üzerinden sayfa içeriğini çeker, retry ile backoff uygular."""
    for attempt in range(1, retries + 1):
        try:
            resp = requests.get(
                url,
                headers=HEADERS,
                proxies={"http": PROXY_URL, "https": PROXY_URL},
                impersonate="chrome120",
                timeout=30,
            )
            if resp.status_code == 200:
                if "captcha" in resp.text.lower():
                    logger.warning("CAPTCHA tespit edildi, IP değiştiriliyor...")
                    return None
                return resp.text
            elif resp.status_code == 429:
                wait = 2 ** attempt
                logger.warning(f"429 alındı, {wait}s bekleniyor...")
                time.sleep(wait)
            else:
                logger.error(f"HTTP {resp.status_code} - {url}")
                return None
        except Exception as e:
            logger.error(f"İstek hatası (deneme {attempt}): {e}")
            time.sleep(2 ** attempt)
    return None

def parse_serp(html: str, target_asin: str) -> dict:
    """SERP HTML'ini parse eder, organik pozisyonu ve Sponsored durumunu döndürür."""
    soup = BeautifulSoup(html, "html.parser")
    results = soup.find_all("div", attrs={"data-component-type": "s-search-result"})

    organic_position = 0
    found = False
    sponsored_position = None

    for card in results:
        asin = card.get("data-asin", "")
        is_sponsored = bool(card.find(string=re.compile(r"Sponsored", re.I)))

        if not is_sponsored:
            organic_position += 1
            if asin == target_asin:
                found = True
                break
        else:
            if asin == target_asin:
                sponsored_position = sponsored_position or organic_position + 1

    return {
        "found": found,
        "organic_position": organic_position if found else None,
        "sponsored_position": sponsored_position,
        "total_results": len(results),
    }

def track_keyword(keyword: str, target_asin: str, max_pages: int) -> list[dict]:
    """Bir anahtar kelime için sayfa 1-N arası sıralamayı takip eder."""
    records = []
    for page in range(1, max_pages + 1):
        url = build_search_url(keyword, page)
        logger.info(f"Sayfa {page} çekiliyor: {url}")
        html = fetch_page(url)
        if not html:
            logger.warning(f"Sayfa {page} alınamadı, atlanıyor.")
            continue

        result = parse_serp(html, target_asin)
        record = {
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "keyword": keyword,
            "asin": target_asin,
            "page": page,
            "found": result["found"],
            "organic_position": result["organic_position"],
            "sponsored_position": result["sponsored_position"],
            "total_results_on_page": result["total_results"],
        }
        records.append(record)

        if result["found"]:
            logger.info(f"ASIN {target_asin} sayfa {page}, organik pozisyon {result['organic_position']}")
            break

        time.sleep(2)  # Sayfalar arası nazik bekleme

    return records

def save_to_csv(records: list[dict], filename: str = "rank_history.csv") -> None:
    """Sıralama geçmişini CSV'ye kaydeder."""
    if not records:
        return
    with open(filename, "a", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=records[0].keys())
        if f.tell() == 0:
            writer.writeheader()
        writer.writerows(records)
    logger.info(f"{len(records)} kayıt {filename} dosyasına yazıldı.")

if __name__ == "__main__":
    records = track_keyword(KEYWORD, TARGET_ASIN, MAX_PAGES)
    save_to_csv(records)
    if not any(r["found"] for r in records):
        logger.warning(f"ASIN {TARGET_ASIN} ilk {MAX_PAGES} sayfada bulunamadı. İndeksasyon kontrolü gerekli.")

Bu örnek, curl_cffi'nin TLS parmak izi taklit yeteneğini (impersonate="chrome120") kullanarak Amazon'un TLS tabanlı bot tespitini aşar. ProxyHat kullanıcı adında -session-rank001 bayrağı, sayfalar arası aynı IP'nin korunmasını sağlar.

Playwright ile Dinamik İçerik Yakalama

Bazı Amazon sayfaları JavaScript ile dinamik yüklenir. Bu durumda curl_cffi yeterli olmayabilir. Playwright ile proxy entegrasyonu şu şekildedir:

import asyncio
from playwright.async_api import async_playwright
from bs4 import BeautifulSoup
import re

PROXY_USER = "user-country-DE-session-pw001"
PROXY_PASS = "your_password"

async def fetch_amazon_page(keyword: str, page: int) -> str:
    """Playwright ile proxy üzerinden Amazon sayfasını render eder."""
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={
                "server": "http://gate.proxyhat.com:8080",
                "username": PROXY_USER,
                "password": PROXY_PASS,
            },
        )
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            locale="en-US",
        )
        page_obj = await context.new_page()
        url = f"https://www.amazon.com/s?k={keyword}&page={page}"
        await page_obj.goto(url, wait_until="domcontentloaded", timeout=45000)
        await page_obj.wait_for_timeout(2000)  # Dinamik içerik için bekle
        html = await page_obj.content()
        await browser.close()
        return html

def find_asin_position(html: str, target_asin: str) -> int | None:
    """Organik pozisyonu döndürür, bulunamazsa None."""
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.find_all("div", attrs={"data-component-type": "s-search-result"})
    pos = 0
    for card in cards:
        asin = card.get("data-asin", "")
        is_sponsored = bool(card.find(string=re.compile(r"Sponsored", re.I)))
        if not is_sponsored:
            pos += 1
            if asin == target_asin:
                return pos
    return None

async def main():
    keyword = "bluetooth speaker"
    target_asin = "B07XJ8C8F5"
    for page_num in range(1, 6):
        html = await fetch_amazon_page(keyword, page_num)
        pos = find_asin_position(html, target_asin)
        if pos:
            print(f"ASIN {target_asin} - Sayfa {page_num}, Pozisyon {pos}")
            break
        await asyncio.sleep(3)
    else:
        print(f"ASIN {target_asin} ilk 5 sayfada bulunamadı.")

asyncio.run(main())

Node.js ile Amazon SERP Scraping

JavaScript/TypeScript kullanan ekipler için aşağıda Node.js örneği bulunmaktadır:

const https = require('https');
const { HttpsProxyAgent } = require('https-proxy-agent');
const cheerio = require('cheerio');

const PROXY_USER = 'user-country-US-session-node001';
const PROXY_PASS = 'your_password';
const PROXY_URL = `http://${PROXY_USER}:${PROXY_PASS}@gate.proxyhat.com:8080`;
const agent = new HttpsProxyAgent(PROXY_URL);

const HEADERS = {
  'Accept': 'text/html,application/xhtml+xml',
  'Accept-Language': 'en-US,en;q=0.9',
  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
};

function fetchPage(keyword, page) {
  return new Promise((resolve, reject) => {
    const url = `https://www.amazon.com/s?k=${encodeURIComponent(keyword)}&page=${page}`;
    const options = { hostname: 'www.amazon.com', path: `/s?k=${encodeURIComponent(keyword)}&page=${page}`, headers: HEADERS, agent };
    https.get(url, { headers: HEADERS, agent }, (res) => {
      let body = '';
      res.on('data', (chunk) => body += chunk);
      res.on('end', () => resolve(body));
    }).on('error', reject);
  });
}

function parsePosition(html, targetAsin) {
  const $ = cheerio.load(html);
  let organicPos = 0;
  $('div[data-component-type="s-search-result"]').each((_, el) => {
    const asin = $(el).attr('data-asin');
    const isSponsored = $(el).text().includes('Sponsored');
    if (!isSponsored) {
      organicPos++;
      if (asin === targetAsin) {
        return organicPos;
      }
    }
  });
  return null;
}

async function main() {
  const keyword = 'wireless charger';
  const targetAsin = 'B07XJ8C8F5';
  for (let page = 1; page <= 5; page++) {
    const html = await fetchPage(keyword, page);
    const pos = parsePosition(html, targetAsin);
    if (pos) {
      console.log(`ASIN ${targetAsin} - Sayfa ${page}, Pozisyon ${pos}`);
      break;
    }
    await new Promise(r => setTimeout(r, 2000));
  }
}

main();

curl Komut Satırı ile Hızlı Test

Kodu yazmadan önce proxy bağlantısını doğrulamak için curl kullanabilirsiniz:

# ProxyHat residential proxy ile Amazon araması
curl -x http://user-country-US-session-test01:your_password@gate.proxyhat.com:8080 \
  -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" \
  -H "Accept-Language: en-US,en;q=0.9" \
  "https://www.amazon.com/s?k=wireless+earbuds&page=1" \
  -o amazon_page1.html

# SOCKS5 ile alternatif
curl -x socks5://user-country-DE-session-test02:your_password@gate.proxyhat.com:1080 \
  -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" \
  "https://www.amazon.de/s?k=kabellose+kopfhörer&page=1" \
  -o amazon_de_page1.html

Çoklu Anahtar Kelime ve ASIN İçin Eşzamanlı Pipeline

Üretim ortamında birden fazla anahtar kelime ve ASIN'i paralel takip etmek için asyncio ve aiohttp kullanabilirsiniz:

import asyncio
import aiohttp
import csv
from datetime import datetime, timezone
from bs4 import BeautifulSoup
import re
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

PROXY_TEMPLATE = "http://user-country-US-session-{session_id}:your_password@gate.proxyhat.com:8080"

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

TRACKING_CONFIG = [
    {"keyword": "wireless earbuds", "asin": "B07XJ8C8F5"},
    {"keyword": "bluetooth speaker", "asin": "B08N5WRWNW"},
    {"keyword": "usb c cable", "asin": "B07XJ8C8F5"},
]

CONCURRENCY = 5

async def fetch_with_retry(session, url, proxy, retries=3):
    for attempt in range(1, retries + 1):
        try:
            async with session.get(url, proxy=proxy, headers=HEADERS, timeout=aiohttp.ClientTimeout(total=30)) as resp:
                if resp.status == 200:
                    text = await resp.text()
                    if "captcha" in text.lower():
                        logger.warning("CAPTCHA algılandı")
                        return None
                    return text
                elif resp.status == 429:
                    await asyncio.sleep(2 ** attempt)
                else:
                    logger.error(f"HTTP {resp.status}")
                    return None
        except Exception as e:
            logger.error(f"Hata (deneme {attempt}): {e}")
            await asyncio.sleep(2 ** attempt)
    return None

def parse_position(html, target_asin):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.find_all("div", attrs={"data-component-type": "s-search-result"})
    pos = 0
    for card in cards:
        asin = card.get("data-asin", "")
        is_sponsored = bool(card.find(string=re.compile(r"Sponsored", re.I)))
        if not is_sponsored:
            pos += 1
            if asin == target_asin:
                return pos
    return None

async def track_one(session, item, sem):
    async with sem:
        session_id = item["keyword"][:8].replace(" ", "")
        proxy = PROXY_TEMPLATE.format(session_id=session_id)
        records = []
        for page in range(1, 6):
            url = f"https://www.amazon.com/s?k={item['keyword'].replace(' ', '+')}&page={page}"
            html = await fetch_with_retry(session, url, proxy)
            if not html:
                continue
            pos = parse_position(html, item["asin"])
            if pos:
                records.append({
                    "timestamp": datetime.now(timezone.utc).isoformat(),
                    "keyword": item["keyword"],
                    "asin": item["asin"],
                    "page": page,
                    "organic_position": pos,
                })
                logger.info(f"{item['keyword']} → sayfa {page}, pozisyon {pos}")
                break
            await asyncio.sleep(2)
        return records

async def main():
    sem = asyncio.Semaphore(CONCURRENCY)
    connector = aiohttp.TCPConnector(limit=CONCURRENCY * 2)
    async with aiohttp.ClientSession(connector=connector) as session:
        tasks = [track_one(session, item, sem) for item in TRACKING_CONFIG]
        results = await asyncio.gall(*tasks)
        all_records = [r for sublist in results for r in sublist]
        if all_records:
            with open("rank_history_async.csv", "a", newline="", encoding="utf-8") as f:
                writer = csv.DictWriter(f, fieldnames=all_records[0].keys())
                if f.tell() == 0:
                    writer.writeheader()
                writer.writerows(all_records)
            logger.info(f"{len(all_records)} kayıt kaydedildi.")

asyncio.run(main())

Üretim İpuçları: Zamanlama, Yeniden Deneme ve İndeksasyon

Günlük Zamanlama

Sıralama takibini günlük olarak çalıştırmak için APScheduler veya bir cron job kullanın. Amazon sıralamaları gün içinde çok değişmediğinden, günde 1 kez takip genellikle yeterlidir. Yoğun dönemlerde (Prime Day, Black Friday) günde 2-3 kez takip mantıklıdır.

Yeniden Deneme ve Backoff

Her istek için en az 3 deneme ve üssel backoff uygulayın. 429 alırsanız, en az 10-15 saniye bekleyin ve farklı bir session ID ile yeni bir IP alın. ProxyHat'te session ID'yi değiştirmek yeni bir IP atar.

CAPTCHA Tespiti

Amazon CAPTCHA gösterdiğinde, yanıt HTML'inde captcha veya robot kelimeleri geçer. Bu durumda:

• Session ID'yi değiştirerek yeni IP alın.
• 15-30 dakika bekleyin.
• İstek hızınızı düşürün (örneğin istekler arası 5 saniye).

İndeksasyon Kontrolü

Bir ASIN hiçbir sayfada bulunamazsa, bu iki anlama gelebilir:

• ASIN bu anahtar kelime için indekslenmemiş (listing optimizasyonu gerekiyor).
• ASIN stokta değil veya askıya alınmış.

İndeksasyonu doğrulamak için Amazon'da ASIN + anahtar kelime şeklinde arama yapın: https://www.amazon.com/s?k=B07XJ8C8F5+wireless+earbuds. Eğer ürün görünüyorsa indeksli demektir; görünmüyorsa listingte bir sorun var.

Residential vs Datacenter vs Mobile Proxy Karşılaştırması

Amazon için residential proxy en iyi dengeyi sunar. Mobile proxy daha güvenli olsa da maliyeti yüksektir. Datacenter proxy ise Amazon'un bot tespiti tarafından hızlıca engellenir. ProxyHat fiyatlandırması sayfasından residential ve mobile planları karşılaştırabilirsiniz.

Etik ve Hukuki Hususlar

python ile amazon sıralamaları takibi yaparken aşağıdaki ilkeleri gözetin:

• Sadece kendi ve herkese açık listeleri takip edin. Rakiplerin özel verilerini toplamak etik dışı olabilir.
• Hız sınırlamasına uyun. Dakikada 60-80 istek, residential proxy için güvenli bir üst sınırdır.
• robots.txt'i kontrol edin. Amazon'un robots.txt dosyası bazı yolların izin verilmediğini belirtebilir.
• SP-API'yi düşünün. Amazon'un Selling Partner API'si, yetkili satıcılar için resmi veri erişimi sunar. Mümkünse resmi API'yi kullanın.
• GDPR ve CCPA uyumu. Kişisel veri toplamıyorsanız sorun yoktur, ancak IP logları ve kullanıcı verileriyle çalışırken dikkatli olun.

Daha geniş web scraping en iyi pratikleri için ilgili kullanım senaryosu sayfamızı inceleyebilirsiniz. ProxyHat teknik dokümanları için docs.proxyhat.com adresini ziyaret edin.

Önemli Çıkarımlar

Özet: Amazon anahtar kelime sıralama takibi, residential proxy olmadan sürdürülebilir şekilde yapılamaz. ProxyHat'ın gate.proxyhat.com:8080 gateway'i üzerinden ülke hedeflemeli ve session bazlı yapışkan IP'ler kullanarak, Amazon'un anti-bot sistemlerini aşabilir ve organik sıralamaları güvenilir şekilde ölçebilirsiniz.

• Amazon SERP'i Google'dan farklıdır; satış hızı ve relevans belirleyicidir.
• data-component-type="s-search-result" ve data-asin ile sonuçları parse edin.
• Sponsored sonuçları organikten ayırın; aksi halde pozisyon yanlış ölçülür.
• Residential proxy + ülke hedeflemesi + sticky session, Amazon scraping için altın üçlüdür.
• Günlük takip, üssel backoff ve CAPTCHA tespiti üretim için zorunludur.
• Mümkünse Amazon SP-API'yi tercih edin; scraping son çare olsun.

SSS

Proxy ile Amazon anahtar kelime sıralama takibi nedir?

Proxy ile Amazon anahtar kelime sıralama takibi, residential veya mobile proxy kullanarak Amazon arama sonuç sayfalarını periyodik olarak kazıyıp, belirli bir ASIN'in organik pozisyonunu anahtar kelime, pazar yeri ve zaman bazında kaydetme işlemidir. Bu, satıcıların listing optimizasyonunu ölçmesine ve reklam stratejisini ayarlamasına olanak tanır.

Proxy ile Amazon anahtar kelime sıralama takibi proxy kullanıcıları için neden önemlidir?

Amazon, datacenter IP'lerini bot trafiği olarak algılar ve hızlıca CAPTCHA veya IP engeli uygular. Residential proxy, gerçek ISP IP'leri sunduğu için bu tespitten kaçınır. Ayrıca ülke hedeflemesi ile pazar yerine özel sonuçlar alınabilir ve sticky session ile pagination boyunca tutarlı IP kullanılabilir.

Amazon anahtar kelime sıralama takibi için hangi proxy tipi en iyisidir?

Residential proxy, Amazon scraping için en iyi dengeyi sunar: düşük tespit riski, makul maliyet ve geniş coğrafi kapsam. Mobile proxy daha güvenlidir ancak maliyeti yüksektir. Datacenter proxy ise Amazon'un bot tespiti tarafından hızlıca engellendiği için önerilmez. ProxyHat, her üç tipi de gate.proxyhat.com gateway'i üzerinden sunar.

Proxy ile Amazon anahtar kelime sıralama takibi yaparken engellemeleri nasıl önlersiniz?

Engellemeleri önlemek için: istekler arası 2-5 saniye bekleme uygulayın, üssel backoff ile yeniden deneyin, her takip döngüsü için benzersiz session ID kullanın, TLS parmak izi taklidi yapan curl_cffi veya Playwright kullanın, CAPTCHA tespiti yapın ve tespit edildiğinde IP değiştirin, günlük takip hacmini 60-80 istek/dakika ile sınırlayın.

Amazon SP-API mi yoksa scraping mi tercih edilmeli?

Mümkünse Amazon SP-API tercih edilmelidir; resmi izinle veri sağlar ve hukuki risk taşımaz. Ancak SP-API tüm anahtar kelime sıralama verilerini sunmaz ve yalnızca yetkili satıcılar içindir. Rakip analiz veya pazar araştırması için scraping gerekebilir; bu durumda yalnızca herkese açık verileri toplayın ve hız sınırlarına uyun.