How to Handle CAPTCHA-Protected Pages When Taking Screenshots

At ScreenshotAPI.net, we are committed to supporting ethical automation practices. By default, our API does not support bypassing CAPTCHA challenges, as these mechanisms are designed to prevent automated access and protect websites from abuse.

However, if your use case falls within legal and ethical boundaries, and you have a legitimate need to work with CAPTCHA-protected content, there are advanced methods you can consider such as integrating third-party proxy solutions.

Using Third-Party Proxies to Work Around CAPTCHAs

CAPTCHAs are often triggered by suspicious traffic patterns, such as those coming from datacenter IP addresses. One way to reduce the likelihood of encountering a CAPTCHA is to route your requests through residential proxies, which mimic regular user traffic more effectively.

For cases where you must access a CAPTCHA-gated page, providers like Bright Data offer tools such as Web Unlocker, which can act as a smart proxy to bypass these challenges.

Important Considerations:

• This solution should be used only when absolutely necessary.
• Response times may be slower.
• Reliability may vary depending on the proxy stability.

Step 1: Set Up Web Unlocker Proxy

To use a CAPTCHA bypass solution like Web Unlocker:

• Sign up for an account with Bright Data.
• Navigate to your dashboard and create a new Web Unlocker proxy zone.
• Enable options such as CAPTCHA-solving and premium domain access if required.
• Once configured, you’ll receive a proxy endpoint that looks something like this:

http://user:[email protected]:22225

Step 2: Use the Proxy with ScreenshotAPI.net

Once you have your proxy URL, you can include it in your screenshot request to ScreenshotAPI.net:

NodeJS

const axios = require("axios");

let config = {
	method: "get",
	maxBodyLength: Infinity,
	url: "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&proxy=http://user:[email protected]:22225&output=image&file_type=png&wait_for_event=load",
	headers: { }
};

axios.request(config).then((response) => {
	console.log(JSON.stringify(response.data));
}.catch((error) => {
	console.log(error);
});

PHP

<?php
	$client = new http.Client;
	$request = new http.Client.Request;
	$request->setRequestUrl("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&proxy=http://user:[email protected]:22225&output=image&file_type=png&wait_for_event=load");
	$request->setRequestMethod("'GET'");
	$request->setOptions(array());

	$client->enqueue($request)->send();
	$response = $client->getResponse();
	echo $response->getBody();
?>

Go

package main

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

func main() {
	url := "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&proxy=http://user:[email protected]:22225&output=image&file_type=png&wait_for_event=load"
	method := "GET"

	client := &http.Client { }
	req, err := http.NewRequest(method, url, nil)

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

	res, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}

	defer res.Body.Close()
	body, err := io.ReadAll(res.Body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(body))
}

Java

OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder().url("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&proxy=http://user:[email protected]:22225&output=image&file_type=png&wait_for_event=load")
	.method("GET", body)
	.build();
Response response = client.newCall(request)
	.execute();

Python

import requests

url = "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&proxy=http://user:[email protected]:22225&output=image&file_type=png&wait_for_event=load"
payload = {}
headers = {}

response = requests.request("GET", url, headers, data=payload)
print(response.text)

Ruby

require "uri"
require "net/http"

url = URI("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fgoogle.com&proxy=http://user:[email protected]:22225&output=image&file_type=png&wait_for_event=load")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)

response = https.request(request)
puts response.read_body

This allows ScreenshotAPI.net to route the request through the proxy, which will handle CAPTCHA resolution on your behalf.

Residential Proxies

If you want to avoid CAPTCHAs altogether without relying on complex solutions, residential proxies are a more lightweight alternative. Since they use IPs assigned to real users, websites are less likely to present CAPTCHA challenges to them.

Several providers, including Bright Data and IPRoyal, offer residential proxy services that can be integrated seamlessly with ScreenshotAPI.net.

Using proxy services to work around CAPTCHA restrictions should always be done responsibly. Make sure you understand the terms of service of the websites you're accessing and comply with all applicable legal and ethical guidelines.