Smart rotating proxies (formerly Crawlera)

import requests
response = requests.get(
    "example.com",
    proxies={
        "http": "http://{}:@proxy.zyte.com:8011/".format(APIKEY),
    }
)
print(response.text)

?php
use GuzzleHttp\Client;

$client = new Client();
$response = $client->get('http://example.com', [
    'proxy' => 'http://APIKEY:@proxy.zyte.com:8011'
]);
echo $response->getBody();
?

require 'curb'
request = Curl::Easy.new("http://example") do |curl|
    curl.proxy_url = "proxy.zyte.com:8011"
    curl.proxypwd = "APIKEY:"
end
request.perform
puts request.body_str

var request = require('request');
request({
    uri: 'http://example.com',
    proxy: 'APIKEY:@proxy.zyte.com:8011'
}, function callback(error, response, body) {
    console.log(body);
});

import java.io.File;
import javax.net.ssl.SSLContext;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.AuthCache;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.BasicAuthCache;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

public class ClientProxyAuthentication {

    public static void main(String[] args) throws Exception {
        
        // Trust own CA and all self-signed certs
        SSLContext sslcontext = SSLContexts.custom()
                .loadTrustMaterial(new File("/path/to/jre/lib/security/cacerts"),
                                   "changeit".toCharArray(),
                                   new TrustSelfSignedStrategy())
                .build();

        // Allow TLSv1.2 protocol only
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslcontext, new String[] {"TLSv1.2"},
                null,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());
        
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(
                new AuthScope("proxy.zyte.com", 8011),
                new UsernamePasswordCredentials("", ""));
        
        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setDefaultCredentialsProvider(credsProvider)
                .setSSLSocketFactory(sslsf)
                .build()) {
            HttpHost target = new HttpHost("example.com", 443, "https");
            HttpHost proxy = new HttpHost("proxy.zyte.com", 8011);

            AuthCache authCache = new BasicAuthCache();

            BasicScheme basicAuth = new BasicScheme();
            basicAuth.processChallenge(
                    new BasicHeader(HttpHeaders.PROXY_AUTHENTICATE,
                                    "Basic realm=\"Zyte\""));
            authCache.put(proxy, basicAuth);

            HttpClientContext ctx = HttpClientContext.create();
            ctx.setAuthCache(authCache);

            RequestConfig config = RequestConfig.custom()
                .setProxy(proxy)
                .build();
            
            HttpGet httpget = new HttpGet("/");
            httpget.setConfig(config);

            try (CloseableHttpResponse response = httpclient.execute(
                target, httpget, ctx)) {
                System.out.println(response.getStatusLine());
                System.out.println(EntityUtils.toString(response.getEntity()));
                EntityUtils.consume(response.getEntity());
            }
        }
    }
}

using System;
using System.IO;
using System.Net;

namespace ProxyRequest
{
    class MainClass
    {
        public static void Main (string[] args)
        {
            var myProxy = new WebProxy("proxy.zyte.com:8011");
            myProxy.Credentials = new NetworkCredential(APIKEY, "");
            
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://example.com");
            request.Proxy = myProxy;
            request.PreAuthenticate = true;
            
            WebResponse response = request.GetResponse();
            Stream dataStream = response.GetResponseStream();
            var reader = new StreamReader(dataStream);

            Console.WriteLine(reader.ReadToEnd());

            reader.Close();
            response.Close();
        }
    }
}

$ curl http://example.com \
      -U APIKEY: \
      -x proxy.zyte.com:8011