Framework Integrations

# middlewares.py
import base64

class ZentisProxyMiddleware:
    def __init__(self, proxy_url, proxy_user, proxy_pass):
        self.proxy_url = proxy_url
        self.proxy_auth = base64.b64encode(
            f"{proxy_user}:{proxy_pass}".encode()
        ).decode()

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            proxy_url=crawler.settings.get("ZENTIS_PROXY_URL"),
            proxy_user=crawler.settings.get("ZENTIS_PROXY_USER"),
            proxy_pass=crawler.settings.get("ZENTIS_PROXY_PASS"),
        )

    def process_request(self, request, spider):
        request.meta["proxy"] = self.proxy_url
        request.headers["Proxy-Authorization"] = (
            b"Basic " + self.proxy_auth.encode()
        )

# settings.py
ZENTIS_PROXY_URL   = "http://gate.zentislabs.com:8080"
ZENTIS_PROXY_USER  = "customer-USERNAME-cc-US"
ZENTIS_PROXY_PASS  = "YOUR_PASSWORD"

DOWNLOADER_MIDDLEWARES = {
    "myproject.middlewares.ZentisProxyMiddleware": 610,
}

# Recommended Scrapy settings for proxy usage
CONCURRENT_REQUESTS           = 16
CONCURRENT_REQUESTS_PER_DOMAIN = 8
DOWNLOAD_DELAY                = 0.25
RETRY_TIMES                   = 3
RETRY_HTTP_CODES              = [429, 500, 502, 503, 504]

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

PROXY = "customer-USERNAME-cc-US:YOUR_PASSWORD@gate.zentislabs.com:8080"

chrome_options = Options()
chrome_options.add_argument(f"--proxy-server=http://{PROXY}")

# For authenticated proxies, use a Chrome extension or Selenium Wire
# Using selenium-wire (recommended):
from seleniumwire import webdriver as sw_webdriver

proxy_options = {
    "proxy": {
        "http":  f"http://{PROXY}",
        "https": f"http://{PROXY}",
        "no_proxy": "localhost,127.0.0.1",
    }
}

driver = sw_webdriver.Chrome(
    options=chrome_options,
    seleniumwire_options=proxy_options,
)

driver.get("https://httpbin.org/ip")
print(driver.page_source)
driver.quit()

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({
    args: ['--proxy-server=http://gate.zentislabs.com:8080'],
    headless: 'new',
  });

  const page = await browser.newPage();

  // Authenticate with the proxy
  await page.authenticate({
    username: 'customer-USERNAME-cc-US',
    password: 'YOUR_PASSWORD',
  });

  // Set realistic viewport and user-agent
  await page.setViewport({ width: 1920, height: 1080 });
  await page.setUserAgent(
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  );

  await page.goto('https://httpbin.org/ip', {
    waitUntil: 'networkidle2',
    timeout: 30000,
  });

  const body = await page.evaluate(() => document.body.innerText);
  console.log('Response:', body);

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

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://gate.zentislabs.com:8080',
      username: 'customer-USERNAME-cc-US',
      password: 'YOUR_PASSWORD',
    },
  });

  const context = await browser.newContext({
    viewport: { width: 1920, height: 1080 },
    userAgent:
      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
  });

  const page = await context.newPage();

  await page.goto('https://httpbin.org/ip', {
    waitUntil: 'networkidle',
  });

  console.log(await page.textContent('body'));
  await browser.close();
})();

import requests

proxies = {
    "http":  "http://customer-USERNAME-cc-US:YOUR_PASSWORD@gate.zentislabs.com:8080",
    "https": "http://customer-USERNAME-cc-US:YOUR_PASSWORD@gate.zentislabs.com:8080",
}

response = requests.get(
    "https://httpbin.org/ip",
    proxies=proxies,
    timeout=30,
)

print(response.json())

const axios = require('axios');

const instance = axios.create({
  proxy: {
    host: 'gate.zentislabs.com',
    port: 8080,
    auth: {
      username: 'customer-USERNAME-cc-US',
      password: 'YOUR_PASSWORD',
    },
  },
  timeout: 30000,
});

const response = await instance.get('https://httpbin.org/ip');
console.log(response.data);