For Paid Users Only

Bulk Screenshots

Our bulk screenshot feature streamlines the process of capturing screenshots for multiple URLs in a single operation. You can choose between two methods:

JSON-Based API – Capture bulk screenshots via RESTful APIs by sending JSON payloads.
CSV File Upload – Upload a CSV file through the website dashboard or API to process multiple URLs at once.

Features

Pause: You can pause the bulk screenshot process at any time by clicking the designated pause button.
Resume: To continue the bulk screenshot process, simply click the provided resume button.
Cancel: To terminate the bulk screenshot process at any point, simply click the cancel button to halt the operation immediately.
Notification: You don’t need to monitor the progress. We will email you a link to download the processed files once all screenshots are ready.

Bulk API

With our JSON-Based bulk API, you can capture bulk screenshots by sending a JSON payload containing the list of URLs and optional configurations.

Send aPOSTrequest to our API with a JSON payload.
The JSON must include an array of URLs and optional parameters like file format, viewport size, injected CSS, delay, and custom headers.
Once processed, you will receive urls to access the screenshots.

const axios = require("axios");
let data = JSON.stringify({"token": "{token}","urls": [	{		"url": "https://whoisfreaks.com/"		"file_type": "png"		"width": 1440		"height": 900		"fresh": true	},	{		"url": "https://ipgeolocation.io/"		"file_type": "png"		"width": 1280		"height": 900		"fresh": true	},	{		"url": "https://apifreaks.com/"		"file_type": "png"		"width": 1024		"height": 720		"fresh": true	},]});
let config = {	method: 'post',	maxBodyLength: Infinity,	url: `https://api.screenshotapi.net/v1/bulk/json?token=${data.token}`,	headers: {
		'Content-Type': 'application/json'
	}	data: data
axios.request(config).then((response) => {	console.log(JSON.stringify(response.data));}).catch((error) => {	console.log(error);});

<?php	$client = new http\Client;	$request = new http\Client\Request;	$request->setRequestUrl('https://api.screenshotapi.net/v1/bulk/json?token={token}');	$request->setRequestMethod('POST');	$body = new http\Message\Body;	$body->append('{
		"token":"{token}",
		"urls": [
			{
				"url": "https://whoisfreaks.com/",
				"file_type": "png",
				"width": 1440,
				"height": 900,
				"fresh": true
			},
			{
				"url": "https://ipgeolocation.io/",
				"file_type": "png",
				"width": 1024,
				"height": 768,
				"fresh": true
			},
			{
				"url": "https://apifreaks.com/",
				"file_type": "png",
				"width": 1024,
				"height": 768,
				"fresh": true
			}
		]
	}');	$request->setBody($body);	$request->setOptions(array());	$request->setHeaders(array('Content-Type' => 'application/json'));	$client->enqueue($request)->send();	$response = $client->getResponse();	echo $response->getBody();?>

package mainimport (	"fmt"	"strings"	"net/http"	"io")func main() {	url := "https://api.screenshotapi.net/v1/bulk/json?token={token}"	method := "POST"	payload := strings.NewReader(`{
  "token":"{token}",
  "urls": [
    {
      "url": "https://www.dell.com/en-us",
      "file_type": "png",
      "width": 1440,
      "height": 900,
      "fresh": true
    },
    {
      "url": "https://www.hp.com/us-en/home.html",
      "file_type": "png",
      "width": 1024,
      "height": 768,
      "fresh": true
    },
    {
      "url": "https://app.screenshotapi.net/",
      "file_type": "png",
      "width": 1024,
      "height": 768,
      "fresh": true
    },
    {
      "url": "https://youtube.com",
      "file_type": "png",
      "width": 1440,
      "height": 900,
      "fresh": true
    }
  ]
}`)	client := &http.Client {}	req, err := http.NewRequest(method, url, payload)	if err != nil {		fmt.Println(err)		return	}	req.Header.Add("Content-Type", "application/json")	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))}

OkHttpClient client = new OkHttpClient().newBuilder().build();MediaType mediaType = MediaType.parse("application/json");RequestBody body = RequestBody.create(mediaType, `{
	"token":"{token}",
	"urls": [
	{
		"url": "https://whoisfreaks.com/",
		"file_type": "png",
		"width": 1440,
		"height": 900,
		"fresh": true
	},
	{
		"url": "https://ipgeolocation.io/",
		"file_type": "png",
		"width": 1024,
		"height": 768,
		"fresh": true
	},
	{
		"url": "https://apifreaks.com/",
		"file_type": "png",
		"width": 1024,
		"height": 768,
		"fresh": true
	},
  ]
}`);Request request = new Request.Builder().url("https://api.screenshotapi.net/v1/bulk/json?token={token}")	.method("POST", body)	.addHeader("Content-Type", "application/json")	.build();Response response = client.newCall(request)	.execute();

import requestsimport jsonurl = "https://api.screenshotapi.net/v1/bulk/json?token={token}"payload = json.dumps({	"token": "{token}"	"urls": [	{		"url": "https://whoisfreaks.com/"		"file_type": "png"		"width": 1440		"height": 900		"fresh": True	},	{		"url": "https://ipgeolocation.io/"		"file_type": "png"		"width": 1024		"height": 768		"fresh": True	},	{		"url": "https://apifreaks.com/"		"file_type": "png"		"width": 1024		"height": 768		"fresh": True	},  ]})headers = {	'Content-Type': 'application/json'}response = requests.request("POST", url, headers = headers, data = payload)print(response.text)

require "uri"require "json"require "net/http"
url = URI("https://api.screenshotapi.net/v1/bulk/json?token={token}")
https = Net::HTTP.new(url.host, url.port)https.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"request.body = JSON.dump({	"token" : "{token}", 	"urls" : [		{			"url" : "https://whoisfreaks.com/", 			"file_type" : "png", 			"width" : 1440, 			"height" : 900, 			"fresh" : true		},		{			"url" : "https://ipgeolocation.io/", 			"file_type" : "png", 			"width" : 1280, 			"height" : 1080, 			"fresh" : true		}, 		{			"url" : "https://apifreaks.com/", 			"file_type" : "png", 			"width" : 1024, 			"height" : 720, 			"fresh" : true		}  ]})response = https.request(request)puts response.read_body

Bulk [CSV file]

You can also capture bulk screenshots by uploading a CSV file. This can be done through:

Website Dashboard – Upload a CSV file directly through our user interface.
RESTful API – Programmatically upload a CSV file through our API endpoint.

const axios = require("axios");const FormData = require("form-data");const fs = require("fs");
let data = new FormData();data.append('csv', fs.createReadStream('{csvPath}'));
let config = {	method: 'post',	maxBodyLength: Infinity,	url: `https://api.screenshotapi.net/v1/bulk/csv?token={token}`,	headers: {
		...data.getHeaders(): 
	}	data: data
axios.request(config).then((response) => {	console.log(JSON.stringify(response.data));}).catch((error) => {	console.log(error);});

<?php	$client = new Client();	$options = [		'multipart' => [			[				'name' => 'csv',				'contents' => Utils::tryFopen('{csvPath}','r'),				'filename' => '{csvPath}',				'headers' => [					'Content-Type' => '<Content-type header>'				]			]		]];	$request = new Request('POST','https://api.screenshotapi.net/v1/bulk/csv?token={token}');	$res = $client->sendAsync($request, $options)->wait();	echo $res->getBody();?>

package mainimport (	"fmt"	"bytes"	"mime/multipart"	"os"	"path/filepath"	"net/http"	"io")func main() {	url := "https://api.screenshotapi.net/v1/bulk/csv?token={token}"	method := "POST"	payload := &bytes.Buffer{}	writer := multipart.NewWriter(payload)	file, errFile1 := os.Open("{csvPath}")	defer file.Close()	part1, errFile1 := writer.CreateFormFile("csv", filepath.Base("{csvPath}"))
	_, errFile1 = io.Copy(part1, file)	if errFile1 != nil {		fmt.Println(errFile1)		return	}
	err := writer.Close()	if err != nil {		fmt.Println(err)		return	}}

OkHttpClient client = new OkHttpClient().newBuilder().build();MediaType mediaType = MediaType.parse("text/plain");RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM).addFormDataPart("csv", "{csvFileName}", 	RequestBody.create(MediaType.parse("application/octet-stream"),	new File("{csvPath}"))).build();Request request = new Request.Builder().url("https://api.screenshotapi.net/v1/bulk/csv?token={token}")	.method("POST", body)	.build();Response response = client.newCall(request)	.execute();

import requests
url = "https://api.screenshotapi.net/v1/bulk/csv?token={token}"payload = {}files = [('csv', ('{csvFileName}', open('{csvPath}', 'rb'), 'text/csv'))]headers = {}response = requests.request("POST", url, headers = headers, data = payload, files = files)
print(response.text)

require "uri"require "net/http"
url = URI("https://api.screenshotapi.net/v1/bulk/csv?token={token}")
https = Net::HTTP.new(url.host, url.port);request = Net::HTTP::Post.new(url)
form_data = [['csv', File.open('{csvPath}')]]request.set_form form_data, 'multipart/form-data'response = https.request(request)
puts response.read_body

Bulk Input File

To submit your bulk screenshot requests, you can either upload a CSV file directly via the Website Dashboard for manual processing, or integrate programmatically using our API endpoint for automated workflows.

Essential Column

URL: The uploaded CSV file must contain a column labeled url. Each entry in this column must include a valid and fully qualified URL starting with the protocolhttps://. Incorrect or incomplete URLs will result in processing errors.

Optional Column

You can include additional columns in the CSV to customize the screenshots. Some of the optional inputs include:

File Type: Specify the output format for the screenshots (e.g., PNG, JPG, or PDF).
Viewport Dimensions: Customize the width and height of the browser viewport during the rendering process.
Injected CSS: Add CSS styles that will be applied during the rendering of the screenshot.
Delay: Introduce a delay (in milliseconds) before capturing the screenshot, useful for dynamic content.
Headers: Add custom HTTP headers to the requests, such as authentication tokens or user-agent strings.

url , file_type , width , height , freshhttps://google.com , png , 1200 , 800 , truehttps://apple.com , jpg , 1920 , 1080 , truehttps://www.mongodb.com , jpg , 1366 , 768 , truehttps://www.dell.com/en-us , pdf , 1440 , 900 , falsehttps://www.hp.com/us-en/home.html , png , 1024 , 768 , false

url , status , screenshot , error_messagehttps://google.com , success , https://storage.screenshotapi.net/google_com_0b052723123a.png , https://apple.com , success , https://storage.screenshotapi.net/apple_com_aa25f3869ade.jpeg , https://www.hp.com/us-en/home.html , success , https://storage.screenshotapi.net/www_hp_com_us_en_home_html_b052723123a3.png , https://www.mongodb.com , success , https://storage.screenshotapi.net/www_mongodb_com_a25f3869ade7.jpeg , https://www.dell.com/en-us , success , https://storage.screenshotapi.net/www_dell_com_en_us_4d57fb6627ed.pdf ,

For more details, please visit Render a screenshot, which provides an exhaustive list of valid headers and their supported values. From advanced options like geolocation and custom headers to basic configurations like file type and delay settings, all request options available for single screenshots are equally applicable for bulk processing. This ensures that the functionality is both comprehensive and user-friendly, empowering you to handle large-scale screenshot tasks effortlessly while maintaining complete control over the output.

Result File Status

You can monitor the progress of your bulk screenshot operation in real time. The system provides detailed insights into how many URLs have been processed, how many remain in the queue, and whether there are any errors or failures.

Website Dashboard: View real-time updates on your bulk dashboard, including completed and pending URLs, directly on the dashboard.
RESTful API: Programmatically check the status using following endpoint to retrieve information such as percent_complete, successful_urls, and failed_urls.

const axios = require("axios");
let config = {	method: "get",	maxBodyLength: Infinity,	url: "https://api.screenshotapi.net/v1/bulk/csv/status?token={token}&uuid={given_uuid}",	headers: { }};
axios.request(config).then((response) => {	console.log(JSON.stringify(response.data));}.catch((error) => {	console.log(error);});

<?php	$client = new http.Client;	$request = new http.Client.Request;	$request->setRequestUrl("https://api.screenshotapi.net/v1/bulk/csv/status?token={token}&uuid={given_uuid}");	$request->setRequestMethod("'GET'");	$request->setOptions(array());
	$client->enqueue($request)->send();	$response = $client->getResponse();	echo $response->getBody();?>

package main
import (	"fmt"	"net/http"	"io")
func main() {	url := "https://api.screenshotapi.net/v1/bulk/csv/status?token={token}&uuid={given_uuid}"	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))}

OkHttpClient client = new OkHttpClient().newBuilder().build();MediaType mediaType = MediaType.parse("text/plain");RequestBody body = RequestBody.create(mediaType, "");Request request = new Request.Builder().url("https://api.screenshotapi.net/v1/bulk/csv/status?token={token}&uuid={given_uuid}")	.method("GET", body)	.build();Response response = client.newCall(request)	.execute();

import requests
url = "https://api.screenshotapi.net/v1/bulk/csv/status?token={token}&uuid={given_uuid}"payload = {}headers = {}
response = requests.request("GET", url, headers, data=payload)print(response.text)

require "uri"require "net/http"
url = URI("https://api.screenshotapi.net/v1/bulk/csv/status?token={token}&uuid={given_uuid}")
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

Download Output File

Once the CSV file is uploaded and the processing starts, our system generates screenshots for each URL specified. The processing time depends on the number of URLs and the complexity of the specified configurations.

Time to Completion: Large batches may take time to complete.
Download Processed Files: Once processing is complete, you can retrieve your screenshots through:
- Website Dashboard: Access and download the processed CSV file directly from your account dashboard.
- RESTful API: Fetch the CSV file programmatically using our API endpoints for seamless integration into your workflow.

const axios = require("axios");
let config = {	method: "get",	maxBodyLength: Infinity,	url: "https://api.screenshotapi.net/v1/bulk/csv/download?token={token}&uuid={given_uuid}",	headers: { }};
axios.request(config).then((response) => {	console.log(JSON.stringify(response.data));}.catch((error) => {	console.log(error);});

<?php	$client = new http.Client;	$request = new http.Client.Request;	$request->setRequestUrl("https://api.screenshotapi.net/v1/bulk/csv/download?token={token}&uuid={given_uuid}");	$request->setRequestMethod("'GET'");	$request->setOptions(array());
	$client->enqueue($request)->send();	$response = $client->getResponse();	echo $response->getBody();?>

package main
import (	"fmt"	"net/http"	"io")
func main() {	url := "https://api.screenshotapi.net/v1/bulk/csv/download?token={token}&uuid={given_uuid}"	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))}

OkHttpClient client = new OkHttpClient().newBuilder().build();MediaType mediaType = MediaType.parse("text/plain");RequestBody body = RequestBody.create(mediaType, "");Request request = new Request.Builder().url("https://api.screenshotapi.net/v1/bulk/csv/download?token={token}&uuid={given_uuid}")	.method("GET", body)	.build();Response response = client.newCall(request)	.execute();

import requests
url = "https://api.screenshotapi.net/v1/bulk/csv/download?token={token}&uuid={given_uuid}"payload = {}headers = {}
response = requests.request("GET", url, headers, data=payload)print(response.text)

require "uri"require "net/http"
url = URI("https://api.screenshotapi.net/v1/bulk/csv/download?token={token}&uuid={given_uuid}")
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

You will receive an email notification with a direct link to the download CSV file once all screenshots are ready.

url , file_type , width , height , freshhttps://google.com , png , 1200 , 800 , truehttps://apple.com , jpg , 1920 , 1080 , truehttps://www.mongodb.com , jpg , 1366 , 768 , truehttps://www.dell.com/en-us , pdf , 1440 , 900 , falsehttps://www.hp.com/us-en/home.html , png , 1024 , 768 , false

url , status , screenshot , error_messagehttps://google.com , success , https://storage.screenshotapi.net/google_com_0b052723123a.png , https://apple.com , success , https://storage.screenshotapi.net/apple_com_aa25f3869ade.jpeg , https://www.hp.com/us-en/home.html , success , https://storage.screenshotapi.net/www_hp_com_us_en_home_html_b052723123a3.png , https://www.mongodb.com , success , https://storage.screenshotapi.net/www_mongodb_com_a25f3869ade7.jpeg , https://www.dell.com/en-us , success , https://storage.screenshotapi.net/www_dell_com_en_us_4d57fb6627ed.pdf ,