Amazon Keyword Rank Tracking mit Proxys: Code-First Guide für Entwickler

Amazon Keyword Rank Tracking mit Proxys: Grundlagen und rechtlicher Hinweis

Dieser Leitfaden behandelt Amazon Keyword Rank Tracking mit Proxys aus Entwicklersicht. Bevor wir in den Code einsteigen, ein kurzer rechtlicher Hinweis: Die hier beschriebenen Techniken erfassen ausschließlich öffentlich zugängliche Suchergebnisse. Im US-Rechtsraum regelt der Computer Fraud and Abuse Act (CFAA) den Zugriff auf fremde Systeme – das Scraping öffentlicher Seiten ohne Authentifizierung wurde durch Van Buren v. United States (2021) teilweise eingeschränkt, aber Vorsicht bleibt geboten. In der EU greift die DSGVO, sobald personenbezogene Daten im Spiel sind – Suchergebnisse enthalten in der Regel keine solchen Daten, aber Logfiles schon. Scrapen Sie nur eigene Listings oder öffentliche Daten, respektieren Sie robots.txt und die Nutzungsbedingungen von Amazon, und ziehen Sie die Amazon SP-API in Betracht, wo verfügbar.

Warum ist Amazon Keyword Rank Tracking mit Proxys überhaupt nötig? Amazon betreibt die größte E-Commerce-Suchmaschine der Welt. Im Gegensatz zu Google ist das Ranking primär durch Relevanz und Sales Velocity gesteuert – nicht durch Backlinks. Ein Seller, der für das Keyword „bluetooth speaker“ auf Position 1 rankt, verkauft deutlich mehr als der auf Position 12. Deshalb müssen Verkäufer ihre organische Position pro Keyword, Marketplace und ASIN kontinuierlich überwachen. Ein amazon keyword rank tracker ist kein Luxus, sondern eine Kernkomponente des Marketplace-SEO-Workflows.

Warum Amazon-Suche eine eigene SERP ist

Amazon-Suchergebnisseiten (SERPs) unterscheiden sich strukturell von Google-SERPs. Jedes Ergebnis ist ein Produkt mit ASIN, Titel, Preis, Bewertung und – entscheidend – einer Sponsored-Markierung für bezahlte Platzierungen. Die organische Position ist das, was Seller tracken müssen. Amazon personalisiert Ergebnisse zudem stark nach Standort, Kaufhistorie und Marketplace (amazon.com, amazon.de, amazon.co.uk etc.). Das bedeutet: Ohne Geo-Targeting über Proxys sehen Sie nicht, was ein Kunde in Deutschland sieht.

Technischer Kontext: Warum Proxys unverzichtbar sind

Amazon betreibt ein aggressives Anti-Bot-System. Es kombiniert TLS-Fingerprinting, IP-Reputations-Checks, Verhaltensanalyse und CAPTCHA-Challenges. Wenn Sie von einer IP aus hunderte Keywords abfragen, wird diese IP typischerweise innerhalb von 50–200 Anfragen gedrosselt oder blockiert. Datacenter-IPs werden schneller erkannt, da Amazon Cloud-Provider-Subnetze (AWS, DigitalOcean, Hetzner) kennt und markiert.

Residential Proxys lösen dieses Problem, weil sie echte ISP-IPs verwenden. Mit Geo-Targeting können Sie Anfragen aus demselben Land stellen, dessen Marketplace Sie scrapen – -country-US für amazon.com, -country-DE für amazon.de. Sticky Sessions (-session-abc123) halten dieselbe IP über mehrere Anfragen hinweg, was für Pagination (Seite 1–5) wichtig ist, da Amazon sonst unterschiedliche Ergebnisse liefert.

Proxy-Typen im Vergleich

Amazon SERP parsen: data-asin und Sponsored-Erkennung

Die Amazon-Suchergebnisseite hat eine vorhersehbare HTML-Struktur. Jedes Ergebnis ist ein <div> mit dem Attribut data-component-type="s-search-result". Die ASIN steht im Attribut data-asin. Bezahlt platzierte Produkte tragen ein Sponsored-Label, das Sie in einem inneren Element finden. Um die organische Position zu berechnen, müssen Sie Sponsored-Ergebnisse ausfiltern oder separat zählen.

Hier ist die Parsing-Logik in Pseudocode:

# Für jedes div[data-component-type='s-search-result']:
#   1. Lese data-asin → ASIN
#   2. Prüfe auf 'Sponsored'-Text → is_sponsored
#   3. Wenn nicht sponsored → organic_position += 1
#   4. Wenn data-asin == target_asin → speichere organic_position

Die organische Position ist nicht identisch mit der Position im DOM, da Sponsored-Ergebnisse dazwischen liegen können. Ein Produkt kann an DOM-Position 3 stehen, aber organisch Position 1 haben, wenn die ersten beiden Sponsored sind.

ProxyHat-Setup: Geo-Targeting und Sticky Sessions

ProxyHat bietet Residential Proxys über das Gateway gate.proxyhat.com an. Die Geo-Targetierung und Session-Steuerelemente werden im Benutzernamen kodiert:

# US-Marketplace (amazon.com), rotierende IP
http://user-country-US:pass@gate.proxyhat.com:8080

# DE-Marketplace (amazon.de), sticky session für Pagination
http://user-country-DE-session-rank01:pass@gate.proxyhat.com:8080

# SOCKS5-Variante
socks5://user-country-DE-session-rank01:pass@gate.proxyhat.com:1080

Die -session--ID sollte pro Keyword+Marketplace-Kombination eindeutig sein, damit die Pagination (Seite 1–5) von derselben IP kommt. Das verhindert, dass Amazon unterschiedliche Personalisierungen ausliefert und Ihre Positionsdaten verfälscht. Mehr dazu in der ProxyHat-Dokumentation.

Code-Beispiel 1: curl-basierte SERP-Abfrage mit ProxyHat

Beginnen wir mit einem einfachen curl-Beispiel, das die erste Seite für ein Keyword auf amazon.de abruft:

#!/bin/bash
# Amazon SERP abrufen – Seite 1, amazon.de, DE-Proxy
KEYWORD="bluetooth speaker"
ENCODED=$(python3 -c "import urllib.parse; print(urllib.parse.quote('$KEYWORD'))")

curl -s \
  --proxy "http://user-country-DE-session-kw001:pass@gate.proxyhat.com:8080" \
  -H "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" \
  -H "Accept-Language: de-DE,de;q=0.9,en;q=0.8" \
  "https://www.amazon.de/s?k=${ENCODED}&page=1" \
  -o serp_de_page1.html

echo "Status: $?"
wc -l serp_de_page1.html

Dieses Beispiel zeigt die Grundkonfiguration. Der Accept-Language-Header muss zum Marketplace passen – für amazon.com verwenden Sie en-US,en;q=0.9. Die -session-kw001-ID sorgt dafür, dass dieselbe IP für nachfolgende Seiten verwendet wird.

Code-Beispiel 2: Python mit curl_cffi und BeautifulSoup

curl_cffi ist eine Python-Bibliothek, die libcurl-ffi mit TLS-Fingerprinting-Unterstützung bietet. Sie ahmt den TLS-Fingerprint echter Browser nach, was für Amazon wichtig ist:

import csv
import time
import logging
from datetime import datetime
from urllib.parse import quote_plus
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__)

PROXY = "http://user-country-DE-session-{kw_id}:pass@gate.proxyhat.com:8080"
TARGET_ASIN = "B0CX123456"  # Ihr ASIN
KEYWORD = "bluetooth speaker"
MARKETPLACE = "https://www.amazon.de"

HEADERS = {
    "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",
    "Accept-Language": "de-DE,de;q=0.9,en;q=0.8",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
}

def fetch_page(url: str, proxy: str, retries: int = 3) -> str | None:
    """Seite mit Retry und Backoff abrufen."""
    for attempt in range(retries):
        try:
            resp = requests.get(url, headers=HEADERS, proxies={"http": proxy, "https": proxy},
                                impersonate="chrome120", timeout=30)
            if resp.status_code == 200:
                return resp.text
            elif resp.status_code == 503:
                logger.warning("503 (Captcha/Wartung), retry in %ds", 2 ** attempt)
                time.sleep(2 ** attempt)
            else:
                logger.error("HTTP %d", resp.status_code)
                return None
        except Exception as e:
            logger.warning("Versuch %d fehlgeschlagen: %s", attempt + 1, e)
            time.sleep(2 ** attempt)
    return None

def parse_serp(html: str, target_asin: str) -> dict:
    """SERP-HTML parsen und organische Position des Target-ASIN finden."""
    soup = BeautifulSoup(html, "html.parser")
    results = soup.select('[data-component-type="s-search-result"]')
    organic_pos = 0
    found = False
    position = None
    is_sponsored = False

    for div in results:
        asin = div.get("data-asin", "")
        sponsored_text = div.get_text()
        sponsored = "Sponsored" in sponsored_text

        if not sponsored and asin:
            organic_pos += 1
            if asin == target_asin:
                found = True
                position = organic_pos
                break

    return {
        "found": found,
        "organic_position": position,
        "total_results": len(results),
    }

def track_keyword(keyword: str, target_asin: str, pages: int = 5) -> dict:
    """Keyword über mehrere Seiten tracken."""
    kw_id = keyword.replace(" ", "_")[:20]
    proxy = PROXY.format(kw_id=kw_id)
    encoded_kw = quote_plus(keyword)

    for page in range(1, pages + 1):
        url = f"{MARKETPLACE}/s?k={encoded_kw}&page={page}"
        logger.info("Abrufe Seite %d: %s", page, url)
        html = fetch_page(url, proxy)
        if not html:
            continue
        result = parse_serp(html, target_asin)
        result["page"] = page
        result["keyword"] = keyword
        result["timestamp"] = datetime.utcnow().isoformat()
        result["marketplace"] = MARKETPLACE

        if result["found"]:
            logger.info("ASIN %s auf Seite %d, Position %d gefunden",
                        target_asin, page, result["organic_position"])
            return result
        time.sleep(2)  # Höflichkeits-Delay zwischen Seiten

    logger.info("ASIN %s in den ersten %d Seiten nicht gefunden", target_asin, pages)
    return {"found": False, "keyword": keyword, "pages_checked": pages}

if __name__ == "__main__":
    result = track_keyword(KEYWORD, TARGET_ASIN, pages=5)
    print(result)

    # In CSV speichern
    with open("rank_history.csv", "a", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["timestamp", "keyword", "marketplace", "found", "organic_position", "page"])
        if f.tell() == 0:
            writer.writeheader()
        writer.writerow(result)

Dieses Skript ruft bis zu 5 Seiten ab, parst jede nach dem Target-ASIN und speichert die Position in einer CSV-Datei. Die impersonate="chrome120"-Option simuliert den TLS-Fingerprint von Chrome 120, was die Block-Wahrscheinlichkeit reduziert.

Code-Beispiel 3: Playwright mit Proxy für JavaScript-Heavy Pages

Manchmal rendert Amazon Suchergebnisse clientseitig. In diesem Fall benötigen Sie einen Headless Browser. Playwright unterstützt Proxys nativ:

import asyncio
from datetime import datetime
from playwright.async_api import async_playwright

PROXY = {
    "server": "http://gate.proxyhat.com:8080",
    "username": "user-country-DE-session-kw01",
    "password": "pass",
}

TARGET_ASIN = "B0CX123456"
KEYWORD = "bluetooth speaker"
MARKETPLACE = "https://www.amazon.de"

async def track_with_playwright(keyword: str, target_asin: str, pages: int = 5):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True, proxy=PROXY)
        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="de-DE",
            extra_http_headers={"Accept-Language": "de-DE,de;q=0.9"},
        )
        page = await context.new_page()

        for pg in range(1, pages + 1):
            url = f"{MARKETPLACE}/s?k={keyword}&page={pg}"
            try:
                await page.goto(url, timeout=30000, wait_until="domcontentloaded")
                await page.wait_for_selector('[data-component-type="s-search-result"]', timeout=10000)

                results = await page.evaluate("""
                    () => {
                        const divs = document.querySelectorAll('[data-component-type="s-search-result"]');n                        let organicPos = 0;n                        const data = [];n                        for (const div of divs) {n                            const asin = div.getAttribute('data-asin') || '';n                            const text = div.textContent || '';
                            const sponsored = text.includes('Sponsored');n                            if (!sponsored && asin) {n                                organicPos++;n                                data.push({asin, organicPos, sponsored: false});n                            } else if (sponsored) {n                                data.push({asin, organicPos: null, sponsored: true});n                            }
                        }n                        return data;n                    }
                """)

                for item in results:
                    if item["asin"] == target_asin and not item["sponsored"]:
                        print(f"[{datetime.utcnow().isoformat()}] ASIN {target_asin} "
                              f"auf Seite {pg}, Position {item['organicPos']}")
                        await browser.close()
                        return {"found": True, "page": pg, "position": item["organicPos"]}

                await asyncio.sleep(2)
            except Exception as e:
                print(f"Fehler auf Seite {pg}: {e}")
                continue

        await browser.close()
        return {"found": False, "pages_checked": pages}

if __name__ == "__main__":
    result = asyncio.run(track_with_playwright(KEYWORD, TARGET_ASIN, pages=5))
    print(result)

Code-Beispiel 4: Multi-Marketplace-Tracking mit asyncio

Wenn Sie mehrere Marketplaces gleichzeitig tracken, ist asynchrone Ausführung effizient. Jeder Marketplace bekommt einen eigenen Proxy mit entsprechendem Ländercode:

import asyncio
import aiohttp
from bs4 import BeautifulSoup
from datetime import datetime
import logging

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

MARKETPLACES = {
    "US": {"url": "https://www.amazon.com", "country": "US", "lang": "en-US,en;q=0.9"},
    "DE": {"url": "https://www.amazon.de", "country": "DE", "lang": "de-DE,de;q=0.9"},
    "UK": {"url": "https://www.amazon.co.uk", "country": "GB", "lang": "en-GB,en;q=0.9"},
}

KEYWORDS = ["bluetooth speaker", "wireless earbuds", "usb c cable"]
TARGET_ASIN = "B0CX123456"

def build_proxy(country: str, session_id: str) -> str:
    return f"http://user-country-{country}-session-{session_id}:pass@gate.proxyhat.com:8080"

async def fetch_and_parse(session: aiohttp.ClientSession, url: str, proxy: str, headers: dict) -> list:
    """Seite abrufen und Ergebnisse parsen."""
    try:
        async with session.get(url, proxy=proxy, headers=headers, timeout=aiohttp.ClientTimeout(total=30)) as resp:
            if resp.status != 200:
                logger.warning("HTTP %d für %s", resp.status, url)
                return []
            html = await resp.text()
            soup = BeautifulSoup(html, "html.parser")
            results = []
            organic = 0
            for div in soup.select('[data-component-type="s-search-result"]'):
                asin = div.get("data-asin", "")
                sponsored = "Sponsored" in (div.get_text() or "")
                if not sponsored and asin:
                    organic += 1
                    results.append({"asin": asin, "organic_position": organic, "sponsored": False})
            return results
    except Exception as e:
        logger.error("Fehler bei %s: %s", url, e)
        return []

async def track_marketplace(mp_code: str, mp_data: dict, keyword: str, target_asin: str):
    """Ein Keyword auf einem Marketplace tracken."""
    session_id = f"{mp_code}_{keyword.replace(' ', '_')[:10]}"
    proxy = build_proxy(mp_data["country"], session_id)
    headers = {
        "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",
        "Accept-Language": mp_data["lang"],
    }

    from urllib.parse import quote_plus
    encoded = quote_plus(keyword)
    url = f"{mp_data['url']}/s?k={encoded}&page=1"

    async with aiohttp.ClientSession() as session:
        results = await fetch_and_parse(session, url, proxy, headers)
        for r in results:
            if r["asin"] == target_asin:
                logger.info("[%s] %s → Position %d", mp_code, keyword, r["organic_position"])
                return {
                    "marketplace": mp_code,
                    "keyword": keyword,
                    "position": r["organic_position"],
                    "timestamp": datetime.utcnow().isoformat(),
                }
        logger.info("[%s] %s → nicht auf Seite 1", mp_code, keyword)
        return {"marketplace": mp_code, "keyword": keyword, "position": None,
                "timestamp": datetime.utcnow().isoformat()}

async def main():
    tasks = []
    for mp_code, mp_data in MARKETPLACES.items():
        for kw in KEYWORDS:
            tasks.append(track_marketplace(mp_code, mp_data, kw, TARGET_ASIN))
    results = await asyncio.gather(*tasks)
    for r in results:
        print(r)

if __name__ == "__main__":
    asyncio.run(main())

Code-Beispiel 5: Tägliche Scheduling-Pipeline mit Retry und CAPTCHA-Erkennung

In der Produktion brauchen Sie Scheduling, Backoff und CAPTCHA-Erkennung. Hier ist eine robustere Pipeline:

import csv
import time
import logging
import json
from datetime import datetime, timedelta
from pathlib import Path
from curl_cffi import requests
from bs4 import BeautifulSoup

logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
logger = logging.getLogger("rank_tracker")

CONFIG = {
    "keywords": ["bluetooth speaker", "wireless earbuds", "usb c cable"],
    "target_asins": ["B0CX123456", "B0AB789012"],
    "marketplace": "https://www.amazon.de",
    "country": "DE",
    "max_pages": 5,
    "delay_between_keywords": 5,  # Sekunden
    "delay_between_pages": 2,
    "max_retries": 3,
    "output_file": "rank_history.csv",
}

def is_captcha(html: str) -> bool:
    """CAPTCHA-Seiten erkennen."""
    captcha_markers = ["Type the characters you see in this image",
                       "captcha", "Robot Check", "automated access"]
    lower = html.lower()
    return any(marker.lower() in lower for marker in captcha_markers)

def fetch_with_backoff(url: str, proxy: str, retries: int = 3) -> str | None:
    for attempt in range(retries):
        try:
            resp = requests.get(
                url,
                headers={
                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
                    "Accept-Language": "de-DE,de;q=0.9",
                },
                proxies={"http": proxy, "https": proxy},
                impersonate="chrome120",
                timeout=30,
            )
            if resp.status_code == 200:
                if is_captcha(resp.text):
                    logger.error("CAPTCHA erkannt! Session pausieren.")
                    time.sleep(60)  # Längere Pause bei CAPTCHA
                    continue
                return resp.text
            elif resp.status_code == 503:
                wait = min(2 ** attempt * 5, 120)  # Max 120s Backoff
                logger.warning("503, warte %ds", wait)
                time.sleep(wait)
            else:
                logger.error("HTTP %d bei %s", resp.status_code, url)
                return None
        except Exception as e:
            logger.warning("Versuch %d: %s", attempt + 1, e)
            time.sleep(min(2 ** attempt * 3, 60))
    return None

def parse_and_find(html: str, target_asin: str) -> dict:
    soup = BeautifulSoup(html, "html.parser")
    results = soup.select('[data-component-type="s-search-result"]')
    organic = 0
    for div in results:
        asin = div.get("data-asin", "")
        sponsored = "Sponsored" in (div.get_text() or "")
        if not sponsored and asin:
            organic += 1
            if asin == target_asin:
                return {"found": True, "position": organic, "page": None}
    return {"found": False, "position": None, "page": None}

def run_daily_tracking():
    """Tägliche Tracking-Pipeline."""
    timestamp = datetime.utcnow().isoformat()
    rows = []

    for keyword in CONFIG["keywords"]:
        kw_id = keyword.replace(" ", "_")[:15]
        proxy = f"http://user-country-{CONFIG['country']}-session-{kw_id}:pass@gate.proxyhat.com:8080"

        for asin in CONFIG["target_asins"]:
            found = False
            for page in range(1, CONFIG["max_pages"] + 1):
                from urllib.parse import quote_plus
                url = f"{CONFIG['marketplace']}/s?k={quote_plus(keyword)}&page={page}"
                logger.info("Tracke '%s' / ASIN %s / Seite %d", keyword, asin, page)

                html = fetch_with_backoff(url, proxy, CONFIG["max_retries"])
                if not html:
                    continue

                result = parse_and_find(html, asin)
                if result["found"]:
                    found = True
                    rows.append({
                        "timestamp": timestamp,
                        "keyword": keyword,
                        "asin": asin,
                        "marketplace": CONFIG["marketplace"],
                        "position": result["position"],
                        "page": page,
                        "found": True,
                    })
                    logger.info("→ Position %d auf Seite %d", result["position"], page)
                    break
                time.sleep(CONFIG["delay_between_pages"])

            if not found:
                rows.append({
                    "timestamp": timestamp,
                    "keyword": keyword,
                    "asin": asin,
                    "marketplace": CONFIG["marketplace"],
                    "position": None,
                    "page": None,
                    "found": False,
                })
                logger.info("→ ASIN %s nicht in ersten %d Seiten", asin, CONFIG["max_pages"])

        time.sleep(CONFIG["delay_between_keywords"])

    # Ergebnisse speichern
    output = Path(CONFIG["output_file"])
    write_header = not output.exists() or output.stat().st_size == 0
    with open(output, "a", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["timestamp", "keyword", "asin", "marketplace", "position", "page", "found"])
        if write_header:
            writer.writeheader()
        writer.writerows(rows)

    logger.info("Tracking abgeschlossen: %d Einträge gespeichert", len(rows))
    return rows

if __name__ == "__main__":
    run_daily_tracking()

Häufige Fehler und Edge Cases

1. Indexation übersehen

Bevor Sie eine Position tracken, prüfen Sie, ob der ASIN überhaupt indexiert ist. Suchen Sie direkt nach der ASIN (https://www.amazon.de/s?k=B0CX123456). Wenn das Produkt dort nicht auftaucht, ist es nicht indexiert und kann für kein Keyword ranken.

2. Sponsored vs. Organic verwechseln

Amazon platziert bis zu 4 Sponsored-Ergebnisse auf Seite 1. Wenn Sie diese nicht herausfiltern, sind Ihre Positionsdaten um 1–4 Positionen verschoben. Die Sponsored-Markierung ist nicht immer im selben Element – prüfen Sie sowohl den sichtbaren Text als auch aria-label-Attribute.

3. Falsche Session-ID bei Pagination

Wenn Sie für jede Seite eine neue Session-ID verwenden, bekommen Sie unterschiedliche IPs und möglicherweise unterschiedliche Personalisierungen. Verwenden Sie eine Session-ID pro Keyword-Abfrage, die über alle Seiten konstant bleibt.

4. Rate Limits ignorieren

Auch mit Residential Proxys sollten Sie nicht mehr als 1 Anfrage pro 2–3 Sekunden pro Session senden. Bei 100 concurrent sessions sind das maximal ~30 requests/s – mehr provoziert CAPTCHAs.

Produktionstipps

• Daily Scheduling: Nutzen Sie cron oder APScheduler, um das Tracking einmal täglich zu einer festen Uhrzeit laufen zu lassen. Amazon aktualisiert Rankings mehrmals täglich, aber tägliche Snapshots reichen für Trend-Analyse.
• Retries mit Backoff: Exponentielles Backoff (2^n Sekunden, max 120s) bei 503- und 429-Antworten.
• CAPTCHA-Erkennung: Prüfen Sie auf „Robot Check“ im HTML. Bei Erkennung sollten Sie die Session 60–300s pausieren und eine neue Session-ID verwenden.
• Datenbank statt CSV: Ab ~1000 Keywords pro Tag wird CSV unhandlich. SQLite oder PostgreSQL mit einem Schema wie (timestamp, keyword, asin, marketplace, position, page) sind besser.
• Monitoring: Loggen Sie Success Rate, Latency und CAPTCHA-Rate. Wenn die Success Rate unter 90% fällt, reduzieren Sie die Concurrency.
• SP-API-Alternative: Für eigene Produkte bietet die Amazon SP-API offizielle Endpunkte für Keyword-Rankings und Suchvolumen. Wo verfügbar, ist das die sauberere Lösung.

Ethik und Best Practices

Tracken Sie nur eigene Listings oder öffentlich sichtbare Daten. Throttlen Sie Ihre Anfragen – 2–5 Sekunden Pause zwischen Keywords ist ein guter Standard. Respektieren Sie robots.txt (Amazon erlaubt bestimmte Pfade, blockiert andere). Für eigene Produkte ist die SP-API die bevorzugte Methode. Für Wettbewerbsanalyse ist SERP-Scraping mit Residential Proxys die gängige Praxis, aber halten Sie sich an vernünftige Raten.

Weitere Ressourcen: Web-Scraping Use Cases, SERP-Tracking, ProxyHat Pricing, Verfügbare Standorte.

Key Takeaways

Amazon SERP ≠ Google SERP. Ranking wird durch Relevanz und Sales Velocity bestimmt, nicht durch Backlinks. Tracken Sie organische Position pro Keyword, Marketplace und ASIN.

Residential Proxys mit Geo-Targeting sind Pflicht. Datacenter-IPs werden von Amazon schnell blockiert. Verwenden Sie -country-DE für amazon.de, -country-US für amazon.com.

Sticky Sessions für Pagination. Eine Session-ID pro Keyword-Abfrage sorgt für konsistente Ergebnisse über mehrere Seiten.

Sponsored herausfiltern. Die organische Position ist nur korrekt, wenn Sie bezahlte Platzierungen separat zählen.

Produktionsreife braucht Backoff, CAPTCHA-Erkennung und Monitoring. Daily Scheduling, Success-Rate-Tracking und SP-API-Alternative wo verfügbar.

FAQ

Was ist Amazon Keyword Rank Tracking mit Proxys?

Es ist der Prozess, bei dem Sie die organische Suchposition eines ASIN für bestimmte Keywords auf Amazon systematisch überwachen, indem Sie Residential Proxys verwenden, um Geo-Targeting und IP-Rotation zu steuern. Dies ermöglicht es Verkäufern, Rankings über mehrere Marketplaces hinweg zu tracken, ohne von Amazons Anti-Bot-System blockiert zu werden.

Warum ist Amazon Keyword Rank Tracking mit Proxys wichtig für Proxy-Nutzer?

Amazon personalisiert Suchergebnisse nach Standort und blockiert Datacenter-IPs schnell. Ohne Residential Proxys mit Länder-Geo-Targeting sehen Sie nicht, was Kunden in einem bestimmten Markt sehen, und Ihre IP wird nach 50–200 Anfragen gedrosselt. Proxys sind die technische Voraussetzung für zuverlässiges, skalierbares Rank-Tracking.

Welcher Proxy-Typ eignet sich am besten für Amazon Keyword Rank Tracking?

Residential Proxys sind die beste Wahl für Amazon SERP-Scraping. Sie bieten echte ISP-IPs mit hoher Reputation, unterstützen Geo-Targeting pro Land und Stadt, und haben ein niedriges Block-Risiko. Datacenter-Proxys werden von Amazon zu schnell erkannt, Mobile-Proxys sind effektiv aber teurer als nötig für diese Anwendung.

Wie vermeidet man Blöcke beim Amazon Keyword Rank Tracking mit Proxys?

Verwenden Sie Sticky Sessions für Pagination, halten Sie 2–5 Sekunden Pause zwischen Keywords, simulieren Sie echte Browser-TLS-Fingerprints (z.B. mit curl_cffi), rotieren Sie Session-IDs bei CAPTCHA-Erkennung, und begrenzen Sie die Concurrency auf 1 Anfrage pro Session. Überwachen Sie die Success Rate und reduzieren Sie die Last bei unter 90%.

Kann man die Amazon SP-API statt Scraping verwenden?

Für eigene Produkte ja. Die Amazon SP-API bietet offizielle Endpunkte für Produkt-Listing-Daten und teilweise Keyword-Insights. Für Wettbewerbsanalyse (Fremd-ASINs) ist die SP-API jedoch nicht ausgelegt, sodass SERP-Scraping mit Proxys die gängige Methode bleibt.