ABCProxy Docs
English
English
  • Overview
  • PROXIES
    • Residential Proxies
      • Introduce
      • Dashboard to Get IP to Use
      • Getting started guide
      • Account security authentication
      • API extraction
      • Basic query
      • Select the country/region
      • Select State
      • Select city
      • Session retention
    • Socks5 Proxies
      • Getting Started
      • Proxy Manager to Get IP to Use
    • Unlimited Residential Proxies
      • Getting started guide
      • Account security authentication
      • API extraction
    • Static Residential Proxies
      • Getting started guide
      • API extraction
      • Account security authentication
    • ISP Proxies
      • Getting started guide
      • Account security authentication
    • Dedicated Datacenter Proxies
      • Getting started guide
      • API extraction
      • Account security authentication
  • Advanced proxy solutions
    • Web Unblocker
      • Get started
      • Making Requests
        • JavaScript rendering
        • Geo-location
        • Session
        • Header
        • Cookie
        • Blocking Resource Loading
    • APM-ABC Proxy Manger
      • How to use
  • SERP API
    • Get started
    • Google
      • Google Search API
      • Google Shopping API
      • Google Local API
      • Google Videos API
      • Google News API
      • Google Flights API
      • Google Product API
      • Google Images API
      • Google Lens Search API
      • Google Play Product API
      • Google Play Game Store API
      • Google Play Book Store API
      • Google Play Movies Store API
      • Google Jobs API
      • Google Scholar Author API
      • Google Scholar API
      • Google Scholar Cite API
      • Google Scholar Profiles API
    • Bing
      • Bing Search API
      • Bing News API
      • Bing Shopping API
      • Bing Images API
      • Bing Videos API
      • Bing Maps API
    • Yahoo
      • Yahoo! Search API
      • Yahoo! Shopping API
      • Yahoo! Images API
      • Yahoo! Videos API
    • DuckDuckGo
      • DuckDuckGo Search API
      • DuckDuckGo News API
      • DuckDuckGo Maps API
    • Ebay
      • Ebay Search API
    • Walmart
      • Walmart Search API
      • Walmart Product Reviews API
      • Walmart Product API
    • Yelp
      • Yelp Reviews API
    • Youtube
      • YouTube Search API
      • YouTube Video API
  • Parametric
    • Google Ads Transparency Center Regions
    • Google GL Parameter: Supported Google Countries
    • Google HL Parameter: Supported Google Languages
    • Google Lens Country Parameter: Supported Google Lens Countries
    • Google Local Services Job Types
    • Google Trends Categories
    • Supported DuckDuckGo Regions
    • Supported Ebay Domains
    • Supported Ebay location options
    • Google Trends Locations
    • Supported Ebay sort options
    • Supported Google Countries via cr parameter
    • Supported Google Domains
    • Supported Google Languages via lr parameter
    • Supported Google Play Apps Categories
    • Supported Google Patents country codes
    • Supported Google Play Games Categories
    • Supported Google Play Books Categories
    • Supported Google Play Movies Categories
    • Supported Google Scholar Courts
    • Supported Yahoo! Countries
    • Supported Yahoo! Domains
    • Supported Yahoo! File formats
    • Supported Yahoo! Languages
    • Supported Yandex Domains
    • Supported Yandex Languages
    • Supported Yelp Domains
    • Supported Yandex Locations
    • Supported Yelp Reviews Languages
    • Walmart Stores Locations
    • Supported Google Travel currency codes
    • Supported Locations API
  • HELP
    • FAQ
      • ABCProxy Software Can Not Log In?
      • Software Tip:“please start the proxy first”
    • Refund Policy
    • Contact Us
  • INTEGRATION AND USAGE
    • Browser Integration Tools
      • Proxy Switchy Omega
      • BP Proxy Switcher
      • Brave Browser
    • Anti-Detection Browser Integration
      • AdsPower
      • BitBrowser
      • Dolphin{anty}
      • Undetectable
      • Incogniton
      • Kameleo
      • Morelogin
      • ClonBrowser
      • Hidemium
      • Helium Scraper
      • VMlogin
      • ixBrower
      • Xlogin
      • Antbrowser
      • Lauth
      • Indigo
      • IDENTORY
      • Gologin
      • MuLogin
    • Use of Enterprise Plan
      • How to use the Enterprise Plan CDKEY?
Powered by GitBook
On this page
  1. Advanced proxy solutions
  2. Web Unblocker

Get started

Using the web unblocker is simple. You need to send a request to our proxy service at unblock.abcproxy.com:17610 with the required authentication -U "username:password" and the JavaScript rendering type X-Abc-Render. Run the following command to access publicly available, legitimate web content:

curl -x unblock.abcproxy.com:17610 -U "username-zone-unblock:password" -H "X-Abc-Render:png" "https://docs.abcproxy.com" -k > abc.png                                    
import requests

# Use your Web Unblocker credentials here.
USERNAME, PASSWORD = 'YOUR_USERNAME-zone-unblock', 'YOUR_PASSWORD'

# Define proxy dict.
proxies = {
  'http': f'http://{USERNAME}:{PASSWORD}@unblock.abcproxy.com:17610',
  'https': f'http://{USERNAME}:{PASSWORD}@unblock.abcproxy.com:17610',
}

headers = {
    'X-Abc-Render': 'html'
}

response = requests.get(
    'https://www.abcproxy.com/',
    verify=False,  # It is required to ignore certificate
    proxies=proxies,
    headers=headers,
)

# Print result page to stdout
print(response.text)

# Save returned HTML to result.html file
with open('result.html', 'w', encoding=response.encoding) as f:
    f.write(response.text)
                      
                  
                                                   
<?php
$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://www.abcproxy.com/');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_PROXY, 'http://unblock.abcproxy.com:17610');
curl_setopt($ch, CURLOPT_PROXYUSERPWD, 'YOUR_USERNAME-zone-unblock' . ':' . 'YOUR_PASSWORD');
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);

curl_setopt_array($ch, array(
    CURLOPT_HTTPHEADER  => array(
        'X-Abc-Render: html'
    )
));

$result = curl_exec($ch);
echo $result;

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close($ch);
                      
                  
                                               
import fetch from 'node-fetch';
import { HttpsProxyAgent } from 'https-proxy-agent';

const username = 'YOUR_USERNAME-zone-unblock';
const password = 'YOUR_PASSWORD';

const agent = new HttpsProxyAgent(
  `http://${username}:${password}@unblock.abcproxy.com:17610`
);

// We recommend accepting our certificate instead of allowing insecure (http) traffic
process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = 0;

const headers = {
   'X-Abc-Render': 'html',
}

const response = await fetch('https://www.abcproxy.com/', {
  method: 'get',
  headers: headers,
  agent: agent,
});

console.log(await response.text());
                      
                  
                                            
package main

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

func main() {
	const Username = "YOUR_USERNAME-zone-unblock"
	const Password = "YOUR_PASSWORD"

	proxyUrl, _ := url.Parse(
		fmt.Sprintf(
			"http://%s:%s@unblock.abcproxy.com:17610",
			Username,
			Password,
		),
	)
	customTransport := &http.Transport{Proxy: http.ProxyURL(proxyUrl)}

	// We recommend accepting our certificate instead of allowing insecure (http) traffic
	customTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

	client := &http.Client{Transport: customTransport}
	request, _ := http.NewRequest("GET",
		"https://www.abcproxy.com/",
		nil,
	)
	
	// Add custom cookies
        request.Header.Add("X-Abc-Render", "html")
        
	request.SetBasicAuth(Username, Password)
	response, _ := client.Do(request)

	responseText, _ := ioutil.ReadAll(response.Body)
	fmt.Println(string(responseText))
}

                      
                  
                                                    
package org.example;

import org.apache.hc.client5.http.auth.AuthScope;
import org.apache.hc.client5.http.auth.CredentialsProvider;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.auth.CredentialsProviderBuilder;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactoryBuilder;
import org.apache.hc.client5.http.ssl.TrustAllStrategy;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.message.StatusLine;
import org.apache.hc.core5.ssl.SSLContextBuilder;

import java.util.Arrays;
import java.util.Properties;


public class Main {

    public static void main(final String[] args)throws Exception {
        final CredentialsProvider credsProvider = CredentialsProviderBuilder.create()
                .add(new AuthScope("unblock.abcproxy.com", 17610), "USERNAME-zone-unblock", "PASSWORD".toCharArray())
                .build();
        final HttpHost target = new HttpHost("https", "https://www.abcproxy.com/", 443);
        final HttpHost proxy = new HttpHost("http", "unblock.abcproxy.com", 17610);
        try (final CloseableHttpClient httpclient = HttpClients.custom()
                .setDefaultCredentialsProvider(credsProvider)
                .setProxy(proxy)
                // We recommend accepting our certificate instead of allowing insecure (http) traffic
                .setConnectionManager(PoolingHttpClientConnectionManagerBuilder.create()
                        .setSSLSocketFactory(SSLConnectionSocketFactoryBuilder.create()
                                .setSslContext(SSLContextBuilder.create()
                                        .loadTrustMaterial(TrustAllStrategy.INSTANCE)
                                        .build())
                                .setHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                                .build())
                        .build())
                .build()) {

            final RequestConfig config = RequestConfig.custom()
                    .build();
            final HttpGet request = new HttpGet("/locations.html");
            request.addHeader("X-Abc-Render","html");
            request.setConfig(config);

            System.out.println("Executing request " + request.getMethod() + " " + request.getUri() +
                    " via " + proxy + " headers: " + Arrays.toString(request.getHeaders()));

            httpclient.execute(target, request, response -> {
                System.out.println("----------------------------------------");
                System.out.println(request + "->" + new StatusLine(response));
                EntityUtils.consume(response.getEntity());
                return null;
            });
        }
    }
}
                                                         
using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

namespace AbcApi
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var webProxy = new WebProxy
            {
                Address = new Uri("http://unblock.abcproxy.com:17610"),
                BypassProxyOnLocal = false,
                UseDefaultCredentials = false,

                Credentials = new NetworkCredential(
                userName: "YOUR_USERNAME-zone-unblock",
                password: "YOUR_PASSWORD"
                )
            };

            var httpClientHandler = new HttpClientHandler
            {
                Proxy = webProxy,
            };

            // We recommend accepting our certificate instead of allowing insecure (http) traffic
            httpClientHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
            httpClientHandler.ServerCertificateCustomValidationCallback =
                (httpRequestMessage, cert, cetChain, policyErrors) =>
                {
                    return true;
                };


            var client = new HttpClient(handler: httpClientHandler, disposeHandler: true);
            
            // Add custom cookies
            client.DefaultRequestHeaders.Add("X-Abc-Render", "html");
            
            Uri baseUri = new Uri("https://www.abcproxy.com/");
            client.BaseAddress = baseUri;

            var requestMessage = new HttpRequestMessage(HttpMethod.Get, "");

            var response = await client.SendAsync(requestMessage);
            var contents = await response.Content.ReadAsStringAsync();

            Console.WriteLine(contents);
        }
    }
}
                      
                  
              

You need to use -k or --insecure to ignore the SSL certificate.

In this command, zone-unblock represents your service type; please do not modify it.

PreviousWeb UnblockerNextMaking Requests

Last updated 15 days ago