Sessions

Add a session ID to reuse the same proxy (IP Address) for multiple requests.

Sessions are the way websites recognize multiple requests coming from the same address. You can create and use a new session in order to scrape multiple pages of the same website and reuse the same proxy (IP Address) for each request.

The value of the X-WSA-Session-ID header can be any integer and is used to identify the new session created by you.

Web Stealth Proxy Session Examples

cURL

curl -k -x "http://stealthproxy.webscrapingapi.com:80" -U "<YOUR-PROXY-USERNAME>:<YOUR-PROXY-PASSWORD>" -X GET "https://httpbin.org/get" --header "X-WSA-Session: 1234"

NodeJS

const axios = require('axios');
const https = require('https');

const instance = axios.create({
  httpsAgent: new https.Agent({  
    rejectUnauthorized: false
  })
});

instance.get('https://httpbin.org/get', {
      proxy: {
          host: 'stealthproxy.webscrapingapi.com',
          port: 8000,
          auth: {
            username: '<YOUR-PROXY-USERNAME>',
            password: '<YOUR-PROXY-PASSWORD>'
          },
          headers: {
            "X-WSA-Session-ID": "1234"
          }    
      }
    }).then(function (response) {
        console.log(response.data);
    }, (err) => {
      console.log(err)
})

Python

import requests

USERNAME = '<YOUR-PROXY-USERNAME>'
PASSWORD = '<YOUR-PROXY-PASSWORD>'

TARGET_URL = 'https://httpbin.org/get'

PROXY = {
   "http": f"https://{ USERNAME }:{ PASSWORD }@stealthproxy.webscrapingapi.com:80"
}

headers = {'X-WSA-Session-ID': "1234"}

response = requests.get(
   url=TARGET_URL,
   proxies=PROXY,
   headers=headers,
   verify=False
)

print(response.text)

PHP

<?php
$ch = curl_init();

$headers = [
    'X-WSA-Session-ID: 1234',
];

curl_setopt($ch, CURLOPT_URL, 'https://httpbin.org/get');

curl_setopt($ch, CURLOPT_PROXY, 'http://<YOUR-PROXY-USERNAME>:<YOUR-PROXY-PASSWORD>@stealthproxy.webscrapingapi.com:80');

curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);


curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);

$response = curl_exec($ch);

if (!$response) {
  die('Error: "'.curl_error($ch).'" - Code: '.curl_errno($ch));
}

echo 'HTTP Status Code: '.curl_getinfo($ch, CURLINFO_HTTP_CODE) . PHP_EOL;
echo 'Response Body: '.$response . PHP_EOL;

curl_close($ch);
?>

Go

package main

import (
    "crypto/tls"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
)

func send_proxy() {
    proxyStr := "https://<YOUR-PROXY-USERNAME>:<YOUR-PROXY-PASSWORD>@stealthproxy.webscrapingapi.com:8000"
    proxyURL, err := url.Parse(proxyStr)

    if err != nil {
        fmt.Println(err)
    }

    transport := &http.Transport{
        Proxy:           http.ProxyURL(proxyURL),
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }

    client := &http.Client{
        Transport: transport,
    }

    req, err := http.NewRequest("GET", "https://httpbin.org/get", nil)
    
    req.Header.Add("X-WSA-Session-ID", "1234")

    parseFormErr := req.ParseForm()
    if parseFormErr != nil {
        fmt.Println(parseFormErr)
    }

    res, err := client.Do(req)

    if err != nil {
        fmt.Println("Failure : ", err)
    }

    body, _ := ioutil.ReadAll(res.Body)

    fmt.Println(res)
    fmt.Println(string(body))
}

func main() {
    send_proxy()
}

.NET

using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main() {

        var proxy = new WebProxy("http://stealthproxy.webscrapingapi.com:80")
        {
            Credentials = new NetworkCredential("<YOUR-PROXY-USERNAME>", "<YOUR-PROXY-PASSWORD>"),
        };

        var clientHandler = new HttpClientHandler
        {
            Proxy = proxy,
        };

        var client = new HttpClient(clientHandler);
        client.DefaultRequestHeaders.Add("X-WSA-Session-ID", "1234");

        var response = await client.GetAsync("http://httpbin.org/get");
        Console.WriteLine(await response.Content.ReadAsStringAsync());
    }
}

Ruby

require 'uri'
require 'net/http'
require 'openssl'

proxy_host = "stealthproxy.webscrapingapi.com"
proxy_port = 80
proxy_user = "<YOUR-PROXY-USERNAME>"
proxy_pass = "<YOUR-PROXY-PASSWORD>"

url = URI("http://httpbin.org/get")

proxy = Net::HTTP::Proxy(proxy_host,
                         proxy_port,
                         proxy_user,
                         proxy_pass)

req = Net::HTTP::Get.new(url.path)

req.add_field("X-WSA-Session-ID", "1234")

response = proxy.start(url.host,url.port) do |http|
  http.request(req)
end
    
puts response.body