Jak zeskrobałem opinie z Amazonu w Pythonie (omijając ekran logowania)

Mój scraper opinii z Amazonu działał bez zarzutu przez sześć tygodni — aż pewnego ranka zwrócił 200 OK i pustą stronę. Bez błędu, bez CAPTCHA, po prostu puste HTML tam, gdzie wcześniej były setki recenzji.

Jeśli brzmi to znajomo, nie jesteś sam. Pod koniec 2025 roku Amazon zaczął ukrywać pełne strony z opiniami za ekranem logowania, a ogromna liczba skryptów do scrapingu w Pythonie przestała działać z dnia na dzień. Ostatnie miesiące spędziłem w , pracując nad tym problemem z dwóch stron — budując nasz scraper AI i jednocześnie utrzymując własny pipeline do opinii w Pythonie — więc uznałem, że czas napisać poradnik, którego sam potrzebowałem, gdy mój skrypt pierwszy raz „umarł”. Ten wpis pokazuje działające podejście: uwierzytelnianie oparte na ciasteczkach, stabilne selektory odporne na zaciemnianie CSS przez Amazon, obejścia limitu 10 stron, zabezpieczenia anty-bot oraz bonusowy moduł analizy sentymentu, który zamienia surowe opinie w realne wnioski biznesowe. A jeśli w połowie pomyślisz: „wolałbym nie utrzymywać całego tego kodu”, pokażę Ci też, jak robi to samo w około dwie minuty i bez Pythona.

Czym jest scraping opinii z Amazonu i dlaczego ma znaczenie?

Scraping opinii z Amazonu to proces programatycznego pobierania danych z recenzji klientów — ocen gwiazdkowych, treści opinii, nazw autorów, dat, oznaczeń „zweryfikowany zakup” — ze stron produktów Amazon. Ponieważ Amazon i nigdy ich nie przywrócił, web scraping pozostaje jedyną programową drogą do tych danych.

Liczby mówią same za siebie. , a . Pokazanie zaledwie 5 recenzji na stronie produktu może . Firmy, które systematycznie analizują sentyment opinii, notują . To nie jest abstrakcyjna nauka o danych — to wywiad konkurencyjny, sygnały do ulepszania produktu i język marketingowy, wszystko zapisane zwykłym tekstem na serwerach Amazonu.

Po co scrapować opinie z Amazonu w Pythonie?

Python nadal jest najczęściej wybieranym językiem do takich zadań. To , a jego ekosystem — requests, BeautifulSoup, pandas, Scrapy — sprawia, że web scraping jest dostępny nawet dla osób, które nie pracują na co dzień jako programiści.

Różne zespoły wykorzystują te dane na różne sposoby:

Jedna marka kuchennego AGD , zmieniła recepturę produktu i odzyskała pozycję numer 1 bestsellerów w ciągu 60 dni. Firma produkująca opaski fitness , zidentyfikowała problem z alergią na lateks, wypuściła wariant hipoalergiczny i zmniejszyła liczbę zwrotów o 40%. To właśnie taki ROI sprawia, że wysiłek inżynieryjny się opłaca.

Ekran logowania: dlaczego scraper opinii z Amazonu przestał działać?

14 listopada 2024 roku . Zmiana została potwierdzona na oraz w . Jeśli wejdziesz na /product-reviews/{ASIN}/ w oknie incognito, zamiast danych o opiniach zobaczysz stronę logowania.

Objawy są podstępne: skrypt dostaje odpowiedź 200 OK, ale w treści HTML zamiast recenzji znajduje się formularz logowania (name="email", id="ap_password"). Bez kodu błędu. Bez CAPTCHA. Po prostu… nic użytecznego.

Amazon zrobił to ze względów anty-botowych i zgodności regionalnej. Egzekwowanie tej reguły jest niespójne — czasem świeże okno przeglądarki pokaże kilka recenzji, zanim pojawi się blokada, zwłaszcza na pierwszej stronie — ale dla scrapera działającego na większą skalę należy zakładać, że blokada jest zawsze aktywna.

Różne krajowe domeny Amazonu (.de, .co.uk, .co.jp) egzekwują tę blokadę niezależnie. Jak napisał jeden użytkownik forum: „do każdego kraju potrzebne jest osobne logowanie”. Twoje ciasteczka z .com nie zadziałają na .co.uk.

Opinie wyróżnione vs. pełna lista recenzji: co nadal da się zobaczyć bez logowania?

Strony produktów Amazonu (/dp/{ASIN}/) nadal pokazują około bez uwierzytelniania. To recenzje wybrane ręcznie przez algorytm Amazonu, przydatne do szybkiej oceny sentymentu, ale nie da się ich sortować, filtrować ani stronicować.

Pełne strony z opiniami (/product-reviews/{ASIN}/) — z sortowaniem według najnowszych, filtrowaniem po gwiazdkach i paginacją obejmującą setki recenzji — wymagają logowania.

Jeśli potrzebujesz tylko kilku opinii do szybkiego sprawdzenia nastroju, zeskrob stronę produktu. Jeśli chcesz setki lub tysiące, musisz obsłużyć uwierzytelnianie.

Co przygotować przed startem: konfiguracja Pythona i bibliotek

Zanim napiszemy jakikolwiek kod, oto zestaw startowy:

• Poziom trudności: średni (swoboda z Pythonem, podstawy HTML)
• Szacowany czas: około 45 minut dla pełnego pipeline’u; około 10 minut dla prostego scrapingu
• Potrzebne rzeczy: Python 3.8+, przeglądarka Chrome, aktywne konto Amazon

Zainstaluj podstawowe biblioteki:

1pip install requests beautifulsoup4 lxml pandas textblob

Opcjonalnie (do bardziej zaawansowanej analizy sentymentu):

1pip install transformers torch

Czym jest ASIN? To 10-znakowy identyfikator produktu w Amazonie. Znajdziesz go w adresie URL produktu — na przykład w amazon.com/dp/B0BCNKKZ91 ASIN to B0BCNKKZ91. To właśnie ten klucz wstawisz do adresu strony z opiniami.

Krok 1: Omiń ekran logowania dzięki uwierzytelnianiu opartemu na ciasteczkach

Najpewniejsze podejście to zalogować się do Amazonu w przeglądarce, skopiować ciasteczka sesji i wstrzyknąć je do requests.Session() w Pythonie. Dzięki temu nie uruchamiasz CAPTCHA ani SMS-owej 2FA, które często psują automatyczne logowanie przez Selenium.

Potrzebujesz tych siedmiu ciasteczek:

Jak wyciągnąć ciasteczka z Chrome DevTools

1. Zaloguj się do amazon.com w Chrome
2. Otwórz DevTools (F12 albo kliknij prawym → Inspect)
3. Przejdź do Application → Storage → Cookies → https://www.amazon.com
4. Znajdź każdą nazwę ciasteczka z tabeli i skopiuj jej wartość
5. Sformatuj je jako ciąg rozdzielany średnikami do użycia w Pythonie

Tak skonfigurujesz sesję:

1import requests
2session = requests.Session()
3# Wklej tutaj wartości swoich ciasteczek
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.headers.update(headers)

Ważne: używaj tego samego obiektu session we wszystkich zapytaniach. Dzięki temu ciasteczka pozostają spójne, a zachowanie bardziej przypomina prawdziwą sesję przeglądarki. Ciasteczka zwykle działają od kilku dni do kilku tygodni przy intensywniejszym scrapingu, ale jeśli znowu zaczniesz trafiać na przekierowania do logowania, odśwież je w przeglądarce.

Dla marketplace’ów innych niż .com nazwy ciasteczek nieco się różnią — amazon.de używa at-acbde zamiast at-main, amazon.co.uk używa at-acbuk itd. Każdy marketplace wymaga osobnej, niezależnej sesji.

Krok 2: Zbuduj zapytanie i parsuj HTML opinii za pomocą BeautifulSoup

Adres URL opinii Amazonu ma taki wzór:

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

Główna funkcja:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Grzeczne opóźnienie
5    response = session.get(url, timeout=15)
6    # Wykrywanie ekranu logowania
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Wykryto ekran logowania — odśwież swoje ciasteczka")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Jest jeszcze jeden prosty trik: zanim wejdziesz na stronę z opiniami, najpierw odwiedź stronę produktu. To buduje bardziej naturalny wzorzec przeglądania w sesji.

1# Najpierw odwiedź stronę produktu (udajemy normalne przeglądanie)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Potem przejdź do opinii
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = get_soup(session, reviews_url)

Krok 3: Użyj stabilnych selektorów do wyciągania danych z opinii (nie opieraj się na klasach CSS)

To miejsce, w którym większość poradników z lat 2022–2023 się wywraca. Amazon zaciemnia nazwy klas CSS — zmieniają się one okresowo, a jak napisał jeden sfrustrowany programista na forum: „żaden z nich nie miał nawet jednego wzorca w nazwach klas tagów span”.

Rozwiązanie: Amazon używa atrybutów data-hook na elementach opinii i są one zaskakująco stabilne. To semantyczne identyfikatory, na których opiera się frontend Amazonu, więc nie są losowo zmieniane.

Kod do ekstrakcji z użyciem selektorów data-hook:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Ocena gwiazdkowa
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # Tytuł
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Treść
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Autor
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Data i kraj
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # Format: "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # Zweryfikowany zakup
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    return reviews

Od miesięcy testuję ten zestaw selektorów na wielu ASIN-ach i atrybuty data-hook ani razu się nie zmieniły. Natomiast klasy CSS w tym samym czasie obróciły się przynajmniej dwa razy.

Krok 4: Obsłuż paginację i limit 10 stron w Amazonie

Amazon ogranicza parametr pageNumber do 10 stron po 10 recenzji każda — twardy limit około 100 opinii na jedną kombinację filtrów. Przycisk „Next page” po stronie 10 po prostu znika.

Podstawowa pętla paginacji:

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # Brak kolejnych opinii na tej stronie
8    all_reviews.extend(page_reviews)
9    print(f"Strona {page}: {len(page_reviews)} opinii")

Jak pobrać więcej niż 10 stron opinii z Amazonu

Sposobem obejścia jest bucketing filtrów. Każda kombinacja filterByStar i sortBy dostaje własne, niezależne okno 10 stron.

Wartości filtra gwiazdek: one_star, two_star, three_star, four_star, five_star
Wartości sortowania: recent, helpful (domyślne)

Łącząc 5 filtrów gwiazdkowych × 2 kolejności sortowania, możesz uzyskać dostęp nawet do 100 stron, czyli 1000 opinii na produkt — a przy produktach z nierównym rozkładem ocen często zbliżysz się do pełnego zestawu recenzji.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Prosta deduplikacja
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # Deduplikacja po zestawie tytuł + autor
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Strona {page}: {len(page_reviews)} opinii")
23print(f"Łącznie unikalnych opinii: {len(all_reviews)}")

Między bucketami pojawiają się duplikaty, więc deduplikacja jest konieczna. Używam pary tytuł opinii + nazwa autora jako szybkiego klucza — nieidealnego, ale wyłapującego zdecydowaną większość duplikatów.

Krok 5: Omijaj zabezpieczenia anty-botowe (rotacja, throttling, retry)

Amazon używa AWS WAF Bot Control, który stał się znacznie bardziej agresywny. Jednowarstwowe zabezpieczenia (np. tylko rotacja User-Agentów albo tylko opóźnienia) już nie wystarczają.

Gotowy do użycia wrapper retry:

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # Wykrywanie blokad
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"Wykryto CAPTCHA. Czekam {wait}s...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"Limit lub blokada ({response.status_code}). Czekam {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Ekran logowania — ciasteczka wygasły")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Próba {attempt + 1} nie powiodła się: {e}")
33    return None

Kilka słów o proxy: Amazon (AWS, GCP, Azure, DigitalOcean) na poziomie sieci. Jeśli scrapujesz więcej niż kilkaset stron, residential proxy są w praktyce konieczne — przygotuj się na koszt rzędu 50–200+ USD miesięcznie, zależnie od wolumenu. Przy mniejszych projektach (poniżej 100 żądań dziennie) ostrożny throttling z własnego IP domowego często wystarcza.

Amazon sprawdza też fingerprint TLS. Standardowa biblioteka Pythona requests ma . Dla scraperów produkcyjnych warto rozważyć curl_cffi, który imituje prawdziwe stosy TLS przeglądarek. Przy scrapingu na poziomie tutoriala (kilkaset stron) requests z dobrymi nagłówkami zwykle wystarcza.

Krok 6: Wyeksportuj zeskrobane opinie z Amazonu do CSV lub Excela

Gdy już zbierzesz opinie, zapisanie ich w użytecznym formacie jest proste dzięki pandas:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"Wyeksportowano {len(df)} opinii do amazon_reviews.csv")

Przykładowy wynik:

Eksport do Excela: df.to_excel("amazon_reviews.xlsx", index=False) (wymaga openpyxl).

Do Google Sheets biblioteka gspread też się nadaje, ale wymaga — tworzenia projektu, włączania dwóch API, generowania danych uwierzytelniających konta serwisowego, udostępnienia arkusza. Jeśli brzmi to jak więcej konfiguracji niż samo scrapowanie, to słusznie. (To jeden z tych momentów, kiedy narzędzie takie jak , eksportujące do Google Sheets jednym kliknięciem, zaczyna wyglądać bardzo atrakcyjnie.)

Bonus: Dodaj analizę sentymentu do zeskrobanych opinii w 5 linijkach Pythona

Większość poradników kończy się na eksporcie CSV. Ale właśnie ocena sentymentu zamienia surowe dane w decyzje biznesowe.

Najszybszy podstawowy wariant używa TextBlob:

1from textblob import TextBlob
2df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)

Dostajesz wynik sentymentu od -1.0 (bardzo negatywny) do +1.0 (bardzo pozytywny) dla każdej opinii. Przykładowy wynik:

Najciekawsze są niezgodności — recenzja 3-gwiazdkowa z pozytywnym tekstem albo 5-gwiazdkowa z negatywnym językiem. Takie rozbieżności często ujawniają subtelne opinie klientów, których same gwiazdki nie pokazują.

Dla dokładności na poziomie produkcyjnym polecam Hugging Face Transformers. , a w porównaniu z narzędziami leksykalnymi. Model nlptown/bert-base-multilingual-uncased-sentiment potrafi nawet przewidywać bezpośrednio ocenę 1–5 gwiazdek:

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

Opinie w Amazonie mają — duży pik przy 5 gwiazdkach, mniejszy przy 1 gwiazdce i dolinę pośrodku. To oznacza, że średnia ocena często słabo opisuje rzeczywistą jakość produktu. Warto wydzielić klaster 1-gwiazdkowy i wyłuskać z niego powtarzające się motywy — zwykle właśnie tam ukrywa się jeden naprawialny defekt.

Szczera wymiana: Python DIY vs płatne API do scrapingu vs Thunderbit

Utrzymuję scrapery Pythona dla Amazonu i mówiąc szczerze: one się psują. Selektory się zmieniają, ciasteczka wygasają, Amazon wdraża nową warstwę wykrywania botów i nagle sobotni poranek zamiast analizy danych zamienia się w debugowanie scrapera. Użytkownicy na forach zgłaszają podobną frustrację — skrypty DIY, które „działały w zeszłym miesiącu”, teraz wymagają ciągłego łatania.

Oto porównanie trzech głównych podejść:

Python daje pełną kontrolę i jest naprawdę najlepszym sposobem, by zrozumieć, jak web scraping działa „pod maską”. Ale jeśli Twoje potrzeby brzmią raczej „potrzebuję danych o opiniach konkurencji w arkuszu do piątku” niż „chcę zbudować produkcyjny pipeline danych”, koszt utrzymania własnego scrapera może być zwyczajnie nieopłacalny.

obsługuje uwierzytelnianie, selektory, paginację i eksport kilkoma kliknięciami — sprawdź i zobacz, czy pasuje do Twojego workflow. Wraz z tym, jak Amazon zaostrza zabezpieczenia anty-botowe, narzędzia oparte na AI, które adaptują się w czasie rzeczywistym, przestają być miłym dodatkiem, a stają się koniecznością.

Możesz też zajrzeć na nasz , gdzie znajdziesz wideo-przewodniki po workflow scrapingu.

FAQ

1. Czy da się scrapować opinie z Amazonu bez logowania?

Tak, ale tylko około 8 „wyróżnionych opinii” widocznych na stronie produktu (/dp/{ASIN}/). Pełne strony z opiniami, sortowaniem, filtrowaniem i paginacją wymagają uwierzytelnienia od końca 2024 roku. W większości zastosowań biznesowych trzeba więc poradzić sobie z ekranem logowania.

2. Czy scrapowanie opinii z Amazonu jest legalne?

Regulamin Amazonu zabrania automatycznego scrapingu. Jednak nowsze orzecznictwo w USA (Meta v. Bright Data, 2024; hiQ v. LinkedIn) wspiera scraping publicznie dostępnych danych. Scraping za logowaniem wiąże się z większym ryzykiem prawnym, ponieważ akceptowałeś regulamin Amazonu przy zakładaniu konta. Przy zastosowaniach komercyjnych skonsultuj się z prawnikiem.

3. Ile opinii z Amazonu mogę zeskrobać na produkt?

Amazon ogranicza liczbę stron opinii do 10 na każdą kombinację sortowania i filtra gwiazdek. Używając wszystkich 5 filtrów gwiazdkowych × 2 kolejności sortowania, można uzyskać nawet 100 stron (około 1000 opinii) na produkt. Przy filtrach słów kluczowych teoretyczny limit jest dużo wyższy, ale duplikacji jest wtedy sporo.

4. Jaka jest najlepsza biblioteka Pythona do scrapowania opinii z Amazonu?

requests + BeautifulSoup do parsowania statycznego HTML to najczęściej używane i najbardziej niezawodne połączenie. Selenium przydaje się, gdy potrzebujesz renderowania JavaScript. Jeśli chcesz alternatywę no-code, która automatycznie obsługuje ekrany logowania i paginację, wypróbuj .

5. Jak uniknąć blokady podczas scrapowania Amazonu?

Rotuj ciągi User-Agent z puli 10+ prawdziwych przeglądarek, dodawaj losowe opóźnienia 2–5 sekund między żądaniami, stosuj wykładniczy backoff przy błędach 503/429, używaj residential proxy przy większej skali (adresy IP centrów danych są blokowane z wyprzedzeniem) i utrzymuj spójne ciasteczka sesji między żądaniami. Jeśli chcesz podejście bez utrzymania, Thunderbit obsługuje zabezpieczenia anty-botowe automatycznie przez Twoją sesję przeglądarki.

Dowiedz się więcej