API Documentation

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything"

curl -L -x "http://YOUR_KEY:@proxy.zenrows.com:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything"

curl -L -x "http://YOUR_KEY:@proxy.zenrows.com:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&antibot=true"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%5D"

curl -L -x "http://YOUR_KEY:js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&wait_for=.content"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&wait=10000"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&block_resources=image%2Cmedia%2Cfont"

curl -L -x "http://YOUR_KEY:js_render=true&block_resources=image%2Cmedia%[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&json_response=true"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&window_width=1920&window_height=1080"

curl -L -x "http://YOUR_KEY:[email protected]s.com:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&premium_proxy=true"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&premium_proxy=true&proxy_country=us"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl -H "Referrer: https://www.google.com" "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&custom_headers=true"

curl -H "Referrer: https://www.google.com" -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&session_id=12345"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&device=desktop"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&original_status=true"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%7D"

curl -L -x "http://YOUR_KEY:css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%[email protected]:8001" -k "https://httpbin.org/anything"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fwww.amazon.com%2Fdp%2FB01LD5GO7I%2F&autoparse=true"

curl -L -x "http://YOUR_KEY:[email protected]:8001" -k "https://www.amazon.com/dp/B01LD5GO7I/"

curl "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything" -X "POST" --data "key1=value1&key2=value2"

curl -L -x "http://YOUR_KEY:@proxy.zenrows.com:8001" -k "https://httpbin.org/anything" -X "POST" --data "key1=value1&key2=value2"

curl "https://api.zenrows.com/v1/usage?apikey=YOUR_KEY"

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:@proxy.zenrows.com:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"

response = client.get(url)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:@proxy.zenrows.com:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"

response = client.get(url)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'js_render': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "js_render": "true"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'antibot': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "antibot": "true"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'js_render': 'true',
	'js_instructions': '[{"click":".button-selector"}]',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "js_render": "true",
    "js_instructions": "[{\"click\":\".button-selector\"}]"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'js_render': 'true',
	'wait_for': '.content',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "js_render": "true",
    "wait_for": ".content"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'js_render': 'true',
	'wait': '10000',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "js_render": "true",
    "wait": 10000
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'js_render': 'true',
	'block_resources': 'image,media,font',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:js_render=true&block_resources=image%2Cmedia%[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "js_render": "true",
    "block_resources": "image,media,font"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'js_render': 'true',
	'json_response': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "js_render": "true",
    "json_response": "true"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'js_render': 'true',
	'window_width': '1920',
	'window_height': '1080',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]s.com:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "js_render": "true",
    "window_width": 1920,
    "window_height": 1080
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'premium_proxy': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "premium_proxy": "true"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'premium_proxy': 'true',
	'proxy_country': 'us',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "premium_proxy": "true",
    "proxy_country": "us"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'custom_headers': 'true',
}
headers = {
	'Referrer': 'https://www.google.com',
}
response = requests.get('https://api.zenrows.com/v1/', params=params, headers=headers)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
headers = {
	"Referrer": "https://www.google.com",
}
response = requests.get(url, proxies=proxies, verify=False, headers=headers)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
headers = {
	"Referrer": "https://www.google.com",
}

response = client.get(url, headers=headers)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'session_id': '12345',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "session_id": 12345
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'device': 'desktop',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "device": "desktop"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'original_status': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "original_status": "true"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'css_extractor': '{"links":"a @href", "images":"img @src"}',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
params = {
    "css_extractor": "{\"links\":\"a @href\", \"images\":\"img @src\"}"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://www.amazon.com/dp/B01LD5GO7I/'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
	'autoparse': 'true',
}
response = requests.get('https://api.zenrows.com/v1/', params=params)
print(response.text)

# pip install requests
import requests

url = "https://www.amazon.com/dp/B01LD5GO7I/"
proxy = "http://YOUR_KEY:[email protected]:8001"
proxies = {"http": proxy, "https": proxy}
response = requests.get(url, proxies=proxies, verify=False)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://www.amazon.com/dp/B01LD5GO7I/"
params = {
    "autoparse": "true"
}

response = client.get(url, params=params)

print(response.text)

# pip install requests
import requests

url = 'https://httpbin.org/anything'
apikey = 'YOUR_KEY'
params = {
    'url': url,
    'apikey': apikey,
}
data = {
	'key1': 'value1',
	'key2': 'value2',
}
response = requests.post('https://api.zenrows.com/v1/', params=params, data=data)
print(response.text)

# pip install requests
import requests

url = "https://httpbin.org/anything"
proxy = "http://YOUR_KEY:@proxy.zenrows.com:8001"
proxies = {"http": proxy, "https": proxy}
data = {
	"key1": "value1",
	"key2": "value2",
}
response = requests.post(url, proxies=proxies, verify=False, data=data)
print(response.text)

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_KEY")
url = "https://httpbin.org/anything"
data = {
	"key1": "value1",
	"key2": "value2",
}

response = client.post(url, data=data)

print(response.text)

# pip install requests
import requests

response = requests.get('https://api.zenrows.com/v1/usage?apikey=YOUR_KEY')
print(response.text)

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:@proxy.zenrows.com:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, []);
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:@proxy.zenrows.com:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, []);
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'js_render': 'true',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "js_render": "true"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'antibot': 'true',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "antibot": "true"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'js_render': 'true',
		'js_instructions': '[{"click":".button-selector"}]',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "js_render": "true",
    "js_instructions": "[{\"click\":\".button-selector\"}]"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'js_render': 'true',
		'wait_for': '.content',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "js_render": "true",
    "wait_for": ".content"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'js_render': 'true',
		'wait': '10000',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "js_render": "true",
    "wait": 10000
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'js_render': 'true',
		'block_resources': 'image,media,font',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:js_render=true&block_resources=image%2Cmedia%[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "js_render": "true",
    "block_resources": "image,media,font"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'js_render': 'true',
		'json_response': 'true',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "js_render": "true",
    "json_response": "true"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'js_render': 'true',
		'window_width': '1920',
		'window_height': '1080',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]s.com:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "js_render": "true",
    "window_width": 1920,
    "window_height": 1080
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'premium_proxy': 'true',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "premium_proxy": "true"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'premium_proxy': 'true',
		'proxy_country': 'us',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "premium_proxy": "true",
    "proxy_country": "us"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	headers: {
		'Referrer': 'https://www.google.com',
	},
	params: {
		'url': url,
		'apikey': apikey,
		'custom_headers': 'true',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
	headers: {
		"Referrer": "https://www.google.com",
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";
	const headers = {
		"Referrer": "https://www.google.com",
	};

    try {
        const { data } = await client.get(url, {
    "custom_headers": "true"
}, { headers });
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'session_id': '12345',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "session_id": 12345
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'device': 'desktop',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "device": "desktop"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'original_status': 'true',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "original_status": "true"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'css_extractor': '{"links":"a @href", "images":"img @src"}',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";

    try {
        const { data } = await client.get(url, {
    "css_extractor": "{\"links\":\"a @href\", \"images\":\"img @src\"}"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://www.amazon.com/dp/B01LD5GO7I/';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'GET', 
	params: {
		'url': url,
		'apikey': apikey,
		'autoparse': 'true',
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://www.amazon.com/dp/B01LD5GO7I/";
const proxy = "http://YOUR_KEY:[email protected]:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "GET",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://www.amazon.com/dp/B01LD5GO7I/";

    try {
        const { data } = await client.get(url, {
    "autoparse": "true"
});
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

const url = 'https://httpbin.org/anything';
const apikey = 'YOUR_KEY';
axios({
	url: 'https://api.zenrows.com/v1/',
	method: 'POST', 
	data: 'key1=value1&key2=value2',
	params: {
		'url': url,
		'apikey': apikey,
	},
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install axios http-proxy-agent https-proxy-agent
const axios = require("axios");
const HttpProxyAgent = require("http-proxy-agent");
const HttpsProxyAgent = require("https-proxy-agent");

const url = "https://httpbin.org/anything";
const proxy = "http://YOUR_KEY:@proxy.zenrows.com:8001";
const httpAgent = new HttpProxyAgent(proxy);
const httpsAgent = new HttpsProxyAgent(proxy);
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
axios({
	url,
	httpAgent,
	httpsAgent,
	method: "POST",
	data: "key1=value1&key2=value2",
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

// npm install zenrows
const { ZenRows } = require("zenrows");

(async () => {
    const client = new ZenRows("YOUR_KEY");
    const url = "https://httpbin.org/anything";
	const postData = "key1=value1&key2=value2";

    try {
        const { data } = await client.post(url, [], { data: postData });
        console.log(data);
    } catch (error) {
        console.error(error.message);
        if (error.response) {
            console.error(error.response.data);
        }
    }
})();

// npm install axios
const axios = require('axios');

axios({
	url: 'https://api.zenrows.com/v1/usage?apikey=YOUR_KEY',
	method: 'GET', 
})
    .then(response => console.log(response.data))
    .catch(error => console.log(error));

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:@proxy.zenrows.com:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:@proxy.zenrows.com:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&antibot=true";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%5D";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&wait_for=.content";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&wait=10000";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&block_resources=image%2Cmedia%2Cfont";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:js_render=true&block_resources=image%2Cmedia%[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&json_response=true";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&window_width=1920&window_height=1080";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]s.com:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&premium_proxy=true";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&premium_proxy=true&proxy_country=us";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&custom_headers=true";
        String response = Request.get(apiUrl)
				.addHeader("Referrer", "https://www.google.com")
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
				.addHeader("Referrer", "https://www.google.com")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&session_id=12345";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&device=desktop";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&original_status=true";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%7D";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://httpbin.org/anything")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fwww.amazon.com%2Fdp%2FB01LD5GO7I%2F&autoparse=true";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:[email protected]:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.get("https://www.amazon.com/dp/B01LD5GO7I/")
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.client5.http.fluent.Form;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything";
        String response = Request.post(apiUrl)
				.bodyForm(Form.form()
					.add("key1", "value1")
					.add("key2", "value2")
					.build())
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

import java.net.URI;
import org.apache.hc.client5.http.fluent.Form;
import java.security.cert.X509Certificate;
import java.util.Base64;
import javax.net.ssl.*;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class ProxyRequest {
    public static void main(final String... args) throws Exception {
        ignoreCertWarning();

        URI uri = new URI("http://YOUR_KEY:@proxy.zenrows.com:8001");
        String basicAuth = new String(Base64.getEncoder().encode(uri.getUserInfo().getBytes()));
        String response = Request.post("https://httpbin.org/anything")
				.bodyForm(Form.form()
					.add("key1", "value1")
					.add("key2", "value2")
					.build())
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(uri))
                .execute().returnContent().asString();

        System.out.println(response);
    }

    private static void ignoreCertWarning() {
        SSLContext ctx = null;
        TrustManager[] trustAllCerts = new X509TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {return null;}
            public void checkClientTrusted(X509Certificate[] certs, String authType) {}
            public void checkServerTrusted(X509Certificate[] certs, String authType) {}
        } };

        try {
            ctx = SSLContext.getInstance("SSL");
            ctx.init(null, trustAllCerts, null);
            SSLContext.setDefault(ctx);
        } catch (Exception e) {}
    }
}

import org.apache.hc.client5.http.fluent.Request;

public class APIRequest {
    public static void main(final String... args) throws Exception {
        String apiUrl = "https://api.zenrows.com/v1/usage?apikey=YOUR_KEY";
        String response = Request.get(apiUrl)
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:@proxy.zenrows.com:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:@proxy.zenrows.com:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&antibot=true');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%5D');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&wait_for=.content');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&wait=10000');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&block_resources=image%2Cmedia%2Cfont');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:js_render=true&block_resources=image%2Cmedia%[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&json_response=true');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&window_width=1920&window_height=1080');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]s.com:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&premium_proxy=true');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&premium_proxy=true&proxy_country=us');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&custom_headers=true');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
	'Referrer: https://www.google.com',
]);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
	'Referrer: https://www.google.com',
]);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&session_id=12345');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&device=desktop');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&original_status=true');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%7D');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fwww.amazon.com%2Fdp%2FB01LD5GO7I%2F&autoparse=true');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://www.amazon.com/dp/B01LD5GO7I/';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:[email protected]:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$postBody = [
	'key1' => 'value1',
	'key2' => 'value2',
];
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($postBody));
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$url = 'https://httpbin.org/anything';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_PROXY, 'http://YOUR_KEY:@proxy.zenrows.com:8001');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$postBody = [
	'key1' => 'value1',
	'key2' => 'value2',
];
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($postBody));
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.zenrows.com/v1/usage?apikey=YOUR_KEY');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
echo $response . PHP_EOL;
curl_close($ch);
?>

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:@proxy.zenrows.com:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:@proxy.zenrows.com:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&antibot=true", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%5D", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:js_render=true&js_instructions=%5B%7B%22click%22%3A%22.button-selector%22%7D%[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&wait_for=.content", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&wait=10000", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&block_resources=image%2Cmedia%2Cfont", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:js_render=true&block_resources=image%2Cmedia%[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&json_response=true", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&js_render=true&window_width=1920&window_height=1080", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]s.com:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&premium_proxy=true", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&premium_proxy=true&proxy_country=us", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&custom_headers=true", nil)
	req.Header.Add("Referrer", "https://www.google.com")
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
	req.Header.Add("Referrer", "https://www.google.com")
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&session_id=12345", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&device=desktop", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&original_status=true", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything&css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%7D", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:css_extractor=%7B%22links%22%3A%22a%20%40href%22%2C%20%22images%22%3A%22img%20%40src%22%[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fwww.amazon.com%2Fdp%2FB01LD5GO7I%2F&autoparse=true", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
)

func main() {
    inputUrl := "https://www.amazon.com/dp/B01LD5GO7I/"
    proxy, _ := url.Parse("http://YOUR_KEY:[email protected]:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("GET", inputUrl, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
	"net/url"
	"strings"
)

func main() {
	form := url.Values{}
	form.Set("key1", "value1")
	form.Set("key2", "value2")

    client := &http.Client{}
    req, err := http.NewRequest("POST", "https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything", strings.NewReader(form.Encode()))
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net/http"
    "net/url"
    "time"
	"strings"
)

func main() {
	form := url.Values{}
	form.Set("key1", "value1")
	form.Set("key2", "value2")

    inputUrl := "https://httpbin.org/anything"
    proxy, _ := url.Parse("http://YOUR_KEY:@proxy.zenrows.com:8001")
    httpClient := &http.Client{
        Timeout: 60 * time.Second,
        Transport: &http.Transport{
            Proxy:           http.ProxyURL(proxy),
            TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        },
    }

    req, err := http.NewRequest("POST", inputUrl, strings.NewReader(form.Encode()))
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    resp, err := httpClient.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

package main

import (
    "io"
    "log"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "https://api.zenrows.com/v1/usage?apikey=YOUR_KEY", nil)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    log.Println(string(body))
}

# gem install faraday
require 'faraday'

url = URI.parse('https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything')
conn = Faraday.new()
conn.options.timeout = 180
res = conn.get(url, nil, nil)
print(res.body)

# gem install faraday
require 'faraday'

url = 'https://httpbin.org/anything'
proxy = 'http://YOUR_KEY:@proxy.zenrows.com:8001'
conn = Faraday.new(proxy: proxy, ssl: {verify: false})
conn.options.timeout = 180
res = conn.get(url, nil, nil)
print(res.body)

# gem install faraday
require 'faraday'

url = URI.parse('https://api.zenrows.com/v1/?apikey=YOUR_KEY&url=https%3A%2F%2Fhttpbin.org%2Fanything')
conn = Faraday.new()
conn.options.timeout = 180
res = conn.get(url, nil, nil)
print(res.body)

# gem install faraday
require 'faraday'

url = 'https://httpbin.org/anything'
proxy = 'http://YOUR_KEY:@proxy.zenrows.com:8001'
conn = Faraday.new(proxy: proxy, ssl: {verify: false})
conn.options.timeout = 180
res = conn.get(url, nil, nil)
print(res.body)