Lalkarz kontra Selenium: co wybrać do skrobania sieci?

Pichai Nurjanah
Wysłane przez
Pichai Nurjanah

Wybierz i kup proxy

Lalkarz kontra Selenium: co wybrać do skrobania sieci?
0 komentarzy

Czy próbujesz wybrać pomiędzy Puppeteerem a Selenium do skrobania sieci? Obydwa są potężnymi strukturami automatyzacji przeglądarki, a dokonanie właściwego wyboru zależy od konkretnych potrzeb w zakresie skrobania i dostępnych zasobów.

Aby pomóc Ci podjąć świadomą decyzję, w poniższej tabeli podkreśliliśmy kluczowe różnice między Puppeteer i Selenium. Następnie zagłębimy się w szczegóły i przedstawimy przykład skrobania dla każdego frameworka, aby zademonstrować jego skuteczność w wydobywaniu danych ze stron internetowych.

KryteriaLalkarzSelen
Kompatybilne językiOficjalnie obsługiwany jest tylko JavaScript, ale istnieją nieoficjalne porty PHP i PythonJava, Python, C#, Ruby, PHP, JavaScript i Kotlin
Obsługa przeglądarkiObsługa Chromu i eksperymentalnej przeglądarki FirefoxChrome, Safari, Firefox, Opera, Edge i Internet Explorer
Wydajność60% szybszy niż SeleniumSzybko
Obsługa systemu operacyjnegoWindows, Linux i macOSWindows, Linux, macOS i Solaris
ArchitekturaArchitektura sterowana zdarzeniami z bezgłowymi instancjami przeglądarkiProtokół JSONWire w sterowniku internetowym do sterowania instancją przeglądarki
Warunki wstępneWystarczy pakiet JavaScriptSelenium Bindings (dla wybranego języka programowania) i sterowniki internetowe przeglądarki
WspólnotaMniejsza społeczność w porównaniu do SeleniumDobrze ugruntowana dokumentacja i duża społeczność

Przejdźmy do szczegółowego omówienia tych bibliotek i przeprowadźmy przykład skrobania dla każdej z nich, aby zilustrować ich skuteczność w wyodrębnianiu danych ze strony internetowej.

Logo lalkarza

Lalkarz

Lalkarz to biblioteka Node.js, która zapewnia interfejs API wysokiego poziomu do kontrolowania przeglądarki Chrome lub Chromium za pośrednictwem protokołu DevTools. Przeznaczony jest do automatyzacji zadań w przeglądarce Chrome lub Chromium, takich jak robienie zrzutów ekranu, generowanie plików PDF i nawigacja po stronach.

Puppeteer może być również używany do testowania stron internetowych poprzez symulację interakcji użytkownika, takich jak klikanie przycisków, wypełnianie formularzy i weryfikacja wyświetlanych wyników.

Zalety Lalkarza

  • Łatwość użycia: Prosty i łatwy w użyciu.
  • W zestawie z chromem: Nie jest wymagana żadna dodatkowa konfiguracja.
  • Tryb bezgłowy: Domyślnie działa w trybie bezgłowym, ale można go skonfigurować tak, aby działał w trybie pełnej przeglądarki.
  • Architektura sterowana zdarzeniami: Eliminuje potrzebę ręcznych wywołań uśpienia w kodzie.
  • Wszechstronne możliwości: Może robić zrzuty ekranu, generować pliki PDF i automatyzować wszystkie działania przeglądarki.
  • Zarządzanie wydajnością: Oferuje narzędzia do rejestrowania czasu działania i wydajności obciążenia w celu optymalizacji i debugowania skrobaka.
  • Pełzanie SPA: Możliwość przeszukiwania aplikacji jednostronicowych (SPA) i generowania wstępnie renderowanej zawartości (renderowanie po stronie serwera).
  • Nagrywanie skryptu: Umożliwia tworzenie skryptów Puppeteer poprzez rejestrowanie działań w przeglądarce za pomocą konsoli DevTools.

Wady Lalkarza

  • Ograniczona obsługa przeglądarek: Obsługuje mniej przeglądarek w porównaniu do Selenium.
  • Koncentruje się na JavaScript: Obsługuje głównie JavaScript, chociaż istnieją nieoficjalne porty dla Pythona i PHP.

Przykład skrobania sieci za pomocą Puppeteera

Przejdźmy przez samouczek dotyczący skrobania sieci Puppeteer, aby wyodrębnić elementy z kategorii Kryminał i Thriller w witrynie Dunaj.

Sklep Danube: kryminały i thrillery

Aby rozpocząć, zaimportuj moduł Puppeteer i utwórz funkcję asynchroniczną, aby uruchomić kod Puppeteer:

const puppeteer = require('puppeteer'); 

async function main() { 
    // Launch a headless browser instance 
    const browser = await puppeteer.launch({ headless: true });

    // Create a new page object 
    const page = await browser.newPage();

    // Navigate to the target URL and wait until the loading finishes
    await page.goto('https://danube-webshop.herokuapp.com/', { waitUntil: 'networkidle2' });

    // Wait for the left-side bar to load
    await page.waitForSelector('ul.sidebar-list');

    // Click on the first element and wait for the navigation to finish
    await Promise.all([
        page.waitForNavigation(),
        page.click("ul[class='sidebar-list'] > li > a"),
    ]);

    // Wait for the book previews to load
    await page.waitForSelector("li[class='preview']");

    // Extract the book previews
    const books = await page.evaluateHandle(
        () => [...document.querySelectorAll("li[class='preview']")]
    );

    // Extract the relevant data using page.evaluate
    const processed_data = await page.evaluate(elements => {
        let data = [];
        elements.forEach(element => {
            let title = element.querySelector("div.preview-title").innerHTML;
            let author = element.querySelector("div.preview-author").innerHTML;
            let rating = element.querySelector("div.preview-details > p.preview-rating").innerHTML;
            let price = element.querySelector("div.preview-details > p.preview-price").innerHTML;

            let result = { title, author, rating, price };
            data.push(result);
        });
        return data;
    }, books);

    // Print out the extracted data
    console.log(processed_data);

    // Close the page and browser respectively
    await page.close();
    await browser.close();
}

// Run the main function to scrape the data
main();

Oczekiwany wynik

Po uruchomieniu kodu wynik powinien wyglądać następująco:

[
    {
        title: 'Does the Sun Also Rise?',
        author: 'Ernst Doubtingway',
        rating: '★★★★☆',
        price: '$9.95'
    },
    {
        title: 'The Insiders',
        author: 'E. S. Hilton',
        rating: '★★★★☆',
        price: '$9.95'
    },
    {
        title: 'A Citrussy Clock',
        author: 'Bethany Urges',
        rating: '★★★★★',
        price: '$9.95'
    }
]

Inny przykład użycia Puppeteer

Oprócz zgarniania danych ze stron internetowych, Puppeteer może być używany do różnych zadań automatyzacji. Jednym z typowych przypadków użycia jest wygenerowanie pliku PDF strony internetowej. Przeanalizujmy przykład, w którym Puppeteer jest używany do generowania pliku PDF ze strony internetowej.

Generowanie pliku PDF w programie Puppeteer

Krok 1: Zaimportuj Lalkarza i utwórz funkcję asynchroniczną

const puppeteer = require('puppeteer');

async function generatePDF() {
    // Launch a headless browser instance
    const browser = await puppeteer.launch({ headless: true });

    // Create a new page object
    const page = await browser.newPage();

    // Navigate to the target URL
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    // Generate a PDF from the web page
    await page.pdf({
        path: 'example.pdf', // Output file path
        format: 'A4',        // Paper format
        printBackground: true, // Include background graphics
    });

    // Close the page and browser respectively
    await page.close();
    await browser.close();
}

// Run the function to generate the PDF
generatePDF();

Dodatkowe opcje lalkarza

Puppeteer udostępnia kilka opcji generowania plików PDF, które można dostosować do własnych potrzeb. Oto niektóre opcje, z których możesz skorzystać:

  • path: Ścieżka pliku, w którym ma zostać zapisany plik PDF.
  • format: Format papieru (np. „A4”, „Letter”).
  • printBackground: Określa, czy dołączyć grafikę tła.
  • landscape: Ustawić true do orientacji poziomej.
  • margin: Określ marginesy pliku PDF (górny, prawy, dolny, lewy).

Przykład z dodatkowymi opcjami:

const puppeteer = require('puppeteer');

async function generatePDF() {
    const browser = await puppeteer.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    await page.pdf({
        path: 'example.pdf',
        format: 'A4',
        printBackground: true,
        landscape: true,
        margin: {
            top: '20px',
            right: '20px',
            bottom: '20px',
            left: '20px',
        },
    });

    await page.close();
    await browser.close();
}

generatePDF();

Przykładowe wyjście

Uruchomienie powyższego kodu spowoduje utworzenie pliku PDF o nazwie example.pdf w bieżącym katalogu z zawartością strony internetowej https://example.com.

Puppeteer to wszechstronne narzędzie do zadań automatyzacji sieci, od skrobania danych po generowanie plików PDF. Łatwość obsługi i zaawansowane funkcje sprawiają, że jest to doskonały wybór do automatyzacji szerokiego zakresu działań przeglądarki. Niezależnie od tego, czy zgarniasz dane, generujesz raporty, czy testujesz strony internetowe, Puppeteer zapewnia narzędzia potrzebne do wydajnej pracy.

Logo Selenu

Selen

Selen to narzędzie typu open source do kompleksowego testowania i automatyzacji sieci, często używane do skrobania sieci. Jego główne komponenty obejmują Selenium IDE, Selenium WebDriver i Selenium Grid.

  • Selen IDE: Służy do rejestrowania działań przed ich automatyzacją.
  • Selenium WebDriver: Wykonuje polecenia w przeglądarce.
  • Siatka selenowa: Umożliwia wykonanie równoległe.

Zalety selenu

  • Łatwość użycia: Prosty i łatwy w użyciu.
  • Wsparcie językowe: Obsługuje różne języki programowania, takie jak Python, Java, JavaScript, Ruby i C#.
  • Automatyzacja przeglądarki: Może automatyzować przeglądarki takie jak Firefox, Edge, Safari, a nawet niestandardowe przeglądarki QtWebKit.
  • Skalowalność: Możliwość skalowania Selenium do setek instancji przy użyciu serwerów w chmurze z różnymi ustawieniami przeglądarki.
  • Wieloplatformowy: Działa w systemach Windows, macOS i Linux.

Wady selenu

  • Złożona konfiguracja: Metody konfiguracji Selenium mogą być złożone.

Próbka skrobania sieci z selenem

Podobnie jak w przypadku Puppeteera, przejrzyjmy samouczek dotyczący skrobania stron internetowych za pomocą Selenium przy użyciu tej samej witryny docelowej. Zapowiedzi książek pobierzemy z kategorii Kryminał i Thriller na stronie Dunaj.

Sklep Danube: kryminały i thrillery

Krok 1: Zaimportuj niezbędne moduły i skonfiguruj Selenium

import time
from selenium import webdriver
from selenium.webdriver.common.by import By

options = webdriver.ChromeOptions()
options.add_argument("--headless")

Krok 2: Zainicjuj sterownik Chrome WebDriver

driver = webdriver.Chrome(options=options)

Krok 3: Przejdź do docelowej witryny internetowej

time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

Krok 4: Kliknij kategorię Kryminały i thrillery i wyodrębnij podglądy książek

time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

Krok 5: Zdefiniuj funkcję wyodrębniającą dane z każdego podglądu książki

def extract(element):
    title = element.find_element(By.CSS_SELECTOR, "div.preview-title").text
    author = element.find_element(By.CSS_SELECTOR, "div.preview-author").text
    rating = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-rating").text
    price = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-price").text
    return {"title": title, "author": author, "rating": rating, "price": price}

Krok 6: Przejdź przeglądanie podglądów, wyodrębnij dane i zamknij sterownik

extracted_data = []
for element in books:
    data = extract(element)
    extracted_data.append(data)

print(extracted_data)
driver.quit()

Oczekiwany wynik

Uruchomienie powyższego kodu da wynik podobny do poniższego:

[
    {'title': 'Does the Sun Also Rise?', 'author': 'Ernst Doubtingway', 'rating': '★★★★☆', 'price': '$9.95'},
    {'title': 'The Insiders', 'author': 'E. S. Hilton', 'rating': '★★★★☆', 'price': '$9.95'},
    {'title': 'A Citrussy Clock', 'author': 'Bethany Urges', 'rating': '★★★★★', 'price': '$9.95'}
]

Dodatkowy przykład Selenium: robienie zrzutu ekranu

Oprócz skrobania danych Selenium można również używać do robienia zrzutów ekranu stron internetowych. Oto przykład wykonania zrzutu ekranu strony internetowej przy użyciu Selenium.

Krok 1: Zaimportuj niezbędne moduły i skonfiguruj Selenium

from selenium import webdriver

options = webdriver.ChromeOptions()
options.add_argument("--headless")

Krok 2: Zainicjuj sterownik Chrome WebDriver

driver = webdriver.Chrome(options=options)

Krok 3: Przejdź do docelowej witryny internetowej

url = "https://example.com"
driver.get(url)

Krok 4: Zrób zrzut ekranu

driver.save_screenshot("example_screenshot.png")

Krok 5: Zamknij sterownik

driver.quit()

Selenium to wszechstronne narzędzie do zadań automatyzacji sieci, w tym skrobania sieci i robienia zrzutów ekranu. Obsługa wielu języków programowania i przeglądarek, a także skalowalność sprawia, że jest to doskonały wybór w przypadku różnych potrzeb związanych z automatyzacją. Niezależnie od tego, czy wyodrębniasz dane, czy generujesz raporty, Selenium zapewnia możliwości skutecznej automatyzacji zadań.

Lalkarz kontra Selen: porównanie prędkości

Czy Puppeteer jest szybszy niż Selenium? Odpowiedź brzmi tak — Puppeteer jest generalnie szybszy niż Selenium.

Aby porównać szybkość Puppeteera i Selenium, użyliśmy piaskownicy sklepu Danube i uruchomiliśmy przedstawione powyżej skrypty 20 razy, uśredniając czas wykonania.

Test prędkości Selenu

Korzystaliśmy z time moduł w Pythonie do pomiaru czasu wykonania skryptu Selenium. Czas rozpoczęcia zapisano na początku, a czas zakończenia na końcu scenariusza. Różnica pomiędzy tymi czasami dała całkowity czas wykonania.

Oto kompletny skrypt używany dla Selenium:

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def extract(element):
    title = element.find_element(By.CSS_SELECTOR, "div.preview-title").text
    author = element.find_element(By.CSS_SELECTOR, "div.preview-author").text
    rating = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-rating").text
    price = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-price").text
    return {"title": title, "author": author, "rating": rating, "price": price}

# Start the timer
start_time = time.time()

options = webdriver.ChromeOptions()
options.add_argument("--headless")

# Create a new instance of the Chrome driver
driver = webdriver.Chrome(options=options)

url = "https://danube-webshop.herokuapp.com/"
driver.get(url)

# Click on the Crime & Thrillers category
time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)

# Extract the book previews
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

extracted_data = []
for element in books:
    data = extract(element)
    extracted_data.append(data)

print(extracted_data)

# End the timer
end_time = time.time()
print(f"The whole script took: {end_time - start_time:.4f} seconds")

driver.quit()

Test szybkości lalkarza

W skrypcie Puppeteer użyliśmy rozszerzenia Date obiekt do pomiaru czasu wykonania. Czas rozpoczęcia zapisano na początku, a czas zakończenia na końcu scenariusza. Różnica pomiędzy tymi czasami dała całkowity czas wykonania.

Oto kompletny skrypt użyty w Puppeteer:

const puppeteer = require('puppeteer');

async function main() {
    const start = Date.now();

    const browser = await puppeteer.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://danube-webshop.herokuapp.com/', { waitUntil: 'networkidle2' });

    await page.waitForSelector('ul.sidebar-list');

    await Promise.all([
        page.waitForNavigation(),
        page.click("ul[class='sidebar-list'] > li > a"),
    ]);

    await page.waitForSelector("li[class='preview']");
    const books = await page.evaluateHandle(
        () => [...document.querySelectorAll("li[class='preview']")]
    );

    const processed_data = await page.evaluate(elements => {
        let data = [];
        elements.forEach(element => {
            let title = element.querySelector("div.preview-title").innerHTML;
            let author = element.querySelector("div.preview-author").innerHTML;
            let rating = element.querySelector("div.preview-details > p.preview-rating").innerHTML;
            let price = element.querySelector("div.preview-details > p.preview-price").innerHTML;

            let result = { title, author, rating, price };
            data.push(result);
        });
        return data;
    }, books);

    console.log(processed_data);
    await page.close();
    await browser.close();

    const end = Date.now();
    console.log(`Execution time: ${(end - start) / 1000} seconds`);
}

main();

Wyniki testu wydajności

Testy wydajnościowe wykazały, że Puppeteer jest o około 60% szybszy od Selenium. Ta przewaga szybkości sprawia, że Puppeteer jest bardziej odpowiednim wyborem w przypadku projektów wymagających szybkiego przeglądania i automatyzacji sieci, szczególnie podczas pracy z przeglądarkami opartymi na Chromium.

Podsumowanie wyników prędkości:

Test prędkości lalkarza kontra selen

Poniższy wykres ilustruje różnicę w wydajności pomiędzy Puppeteer i Selenium:

Skalowanie aplikacji Puppeteer pod kątem projektów wymagających szybkiego i wydajnego przeglądania sieci jest w tym kontekście optymalnym wyborem.

Lalkarz kontra Selen: co jest lepsze?

Który z nich jest lepszy do skrobania między Selenium a Puppeteer? Nie ma bezpośredniej odpowiedzi na to pytanie, ponieważ zależy to od wielu czynników, takich jak długoterminowe wsparcie bibliotek, obsługa różnych przeglądarek i Twoje potrzeby w zakresie skrobania sieci.

Puppeteer jest szybszy, ale w porównaniu do Selenium obsługuje mniej przeglądarek. Selenium obsługuje także więcej języków programowania w porównaniu do Puppeteer.

Wniosek

Chociaż używanie Puppeteera lub Selenium jest dobrą opcją do skrobania stron internetowych, skalowanie i optymalizacja projektu skrobania sieci może być wyzwaniem, ponieważ zaawansowane zabezpieczenia przed botami mogą wykrywać i blokować te biblioteki. Najlepszym sposobem na uniknięcie tego jest użycie interfejsu API do skrobania sieci, takiego jak OneProxy.

Korzystanie z Puppeteera z serwerami proxy

Aby używać Puppeteera z serwerem proxy, możesz przekazać ustawienia proxy w pliku args opcja podczas uruchamiania instancji przeglądarki. Oto przykład:

const puppeteer = require('puppeteer');

async function main() {
    const proxyServer = 'http://your-proxy-server:port';
    
    const browser = await puppeteer.launch({
        headless: true,
        args: [`--proxy-server=${proxyServer}`]
    });

    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    // Perform your web scraping tasks here

    await browser.close();
}

main();

Używanie Selenium z serwerami proxy

Aby używać Selenium z serwerem proxy, możesz ustawić opcje proxy za pomocą webdriver.Proxy klasa. Oto przykład:

from selenium import webdriver
from selenium.webdriver.common.proxy import Proxy, ProxyType

proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = "your-proxy-server:port"
proxy.ssl_proxy = "your-proxy-server:port"

capabilities = webdriver.DesiredCapabilities.CHROME
proxy.add_to_capabilities(capabilities)

options = webdriver.ChromeOptions()
options.add_argument("--headless")

driver = webdriver.Chrome(desired_capabilities=capabilities, options=options)
driver.get("https://example.com")

# Perform your web scraping tasks here

driver.quit()

Korzystanie z serwerów proxy w połączeniu z Puppeteer i Selenium może pomóc ominąć ograniczenia oparte na adresach IP i zmniejszyć ryzyko zablokowania, zwiększając efektywność zadań związanych z przeglądaniem sieci. Obrotowe serwery proxy OneProxy może jeszcze bardziej zoptymalizować ten proces, zapewniając płynne skrobanie.

Często zadawane pytania (FAQ)

Zarówno Puppeteer, jak i Selenium to platformy automatyzacji przeglądarki używane do przeglądania sieci, testowania i automatyzacji zadań przeglądarki. Puppeteer to biblioteka Node.js, która kontroluje przeglądarkę Chrome lub Chromium za pośrednictwem protokołu DevTools, natomiast Selenium to narzędzie typu open source, które obsługuje różne przeglądarki i języki programowania za pośrednictwem interfejsu API WebDriver.

Puppeteer jest generalnie szybszy niż Selenium. Jednak różnica prędkości może się różnić w zależności od konkretnych zadań i konfiguracji używanych w projektach skrobania sieci lub automatyzacji.

Puppeteer jest znany ze swojej łatwości obsługi, szybkości i możliwości automatyzacji zadań domyślnie w trybie bezgłowym. Obsługuje Chromium i ma silną architekturę sterowaną zdarzeniami, która eliminuje potrzebę ręcznych wywołań uśpienia w kodzie.

Puppeteer obsługuje mniej przeglądarek w porównaniu do Selenium i koncentruje się głównie na JavaScript, chociaż istnieją nieoficjalne porty dla innych języków, takich jak Python i PHP.

Możesz skonfigurować Puppeteera do korzystania z serwera proxy, przekazując ustawienia proxy w pliku args opcję podczas uruchamiania przeglądarki.

Selenium obsługuje wiele języków programowania (Python, Java, JavaScript, Ruby, C#) i może automatyzować różne przeglądarki, w tym Firefox, Edge, Safari i niestandardowe przeglądarki, takie jak QtWebKit. Pozwala także na szeroką skalowalność poprzez techniki takie jak konfigurowanie serwerów w chmurze z różnymi ustawieniami przeglądarki.

Selenium może być bardziej skomplikowane w konfiguracji w porównaniu do Puppeteera, szczególnie podczas konfigurowania go dla różnych przeglądarek i środowisk.

Możesz skonfigurować serwer proxy w Selenium za pomocą webdriver.Proxy klasa.

Przeprowadziliśmy te same zadania skrobania sieci w piaskownicy sklepu Danube, używając zarówno Puppeteera, jak i Selenium. Każdy skrypt został wykonany 20 razy i obliczono średni czas wykonania w celu porównania wydajności.

Wyniki pokazały, że Puppeteer jest o około 60% szybszy niż Selenium, co czyni go lepszym wyborem do szybkiego skrobania sieci i zadań automatyzacji.

OneProxy może pomóc Ci uniknąć zablokowania. OneProxy obsługuje omijanie botów, zapewnia rotacyjne serwery proxy, przeglądarki bezobsługowe, automatyczne ponawianie prób i wiele więcej, zapewniając płynne przeglądanie sieci.

ZOSTAW KOMENTARZ

Serwery proxy centrum danych
Udostępnione proxy

Ogromna liczba niezawodnych i szybkich serwerów proxy.

Zaczynać od$0.06 na adres IP
Rotacyjne proxy
Rotacyjne proxy

Nielimitowane rotacyjne proxy w modelu pay-per-request.

Zaczynać od$0.0001 na żądanie
Prywatne proxy
Serwery proxy UDP

Serwery proxy z obsługą UDP.

Zaczynać od$0.4 na adres IP
Prywatne proxy
Prywatne proxy

Dedykowane proxy do użytku indywidualnego.

Zaczynać od$5 na adres IP
Nieograniczone proxy
Nieograniczone proxy

Serwery proxy z nieograniczonym ruchem.

Zaczynać od$0.06 na adres IP
Gotowy do korzystania z naszych serwerów proxy już teraz?
od $0.06 na adres IP