Instant Capture
Capture screenshots instantly with our API, which processes URLs in real time, delivering up-to-the-minute snapshots.
Programmatically capture screenshots of URLs to streamline documentation, ensure compliance, and monitor web changes effectively.
// Returns the raw PNG image bytes for the requested URL. // The response body is binary image data (Content-Type: image/png), // not JSON. Write the bytes straight to a .png file to view the // captured screenshot of the page.
import requests
api_key = "5eaa61a6e562fc52fe763tr516e4653"
url = "https://api.scrapingdog.com/screenshot"
params = {
"api_key": api_key,
"url": "https://www.scrapingdog.com/"
}
response = requests.get(url, params=params)
if response.status_code == 200:
# The response body is raw PNG image bytes, save it to a file.
with open("screenshot.png", "wb") as f:
f.write(response.content)
print("Screenshot saved to screenshot.png")
else:
print(f"Request failed with status code: {response.status_code}")import java.io.InputStream;
import java.io.FileOutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
try {
// Set the API key and request parameters
String apiKey = "5eaa61a6e562fc52fe763tr516e4653";
String targetUrl = "https://www.scrapingdog.com/";
// Construct the API endpoint URL
String apiUrl = "https://api.scrapingdog.com/screenshot?api_key=" + apiKey
+ "&url=" + targetUrl;
URL url = new URL(apiUrl);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
// The response body is raw PNG image bytes, save it to a file.
InputStream in = connection.getInputStream();
FileOutputStream out = new FileOutputStream("screenshot.png");
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
}
out.close();
in.close();
System.out.println("Screenshot saved to screenshot.png");
} else {
System.out.println("HTTP request failed with response code: " + responseCode);
}
connection.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
}<?php
// Set the API key and request parameters
$api_key = '5eaa61a6e562fc52fe763tr516e4653';
$target_url = 'https://www.scrapingdog.com/';
// Set the API endpoint
$url = 'https://api.scrapingdog.com/screenshot?api_key=' . $api_key . '&url=' . urlencode($target_url);
// Initialize cURL session
$ch = curl_init($url);
// Set cURL options
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
// Execute the cURL request
$response = curl_exec($ch);
// Check if the request was successful
if ($response === false) {
echo 'cURL error: ' . curl_error($ch);
} else {
// The response body is raw PNG image bytes, save it to a file.
file_put_contents('screenshot.png', $response);
echo 'Screenshot saved to screenshot.png';
}
// Close the cURL session
curl_close($ch);require 'net/http'
require 'uri'
# Set the API key and request parameters
api_key = '5eaa61a6e562fc52fe763tr516e4653'
target_url = 'https://www.scrapingdog.com/'
# Construct the API endpoint URL
url = URI.parse("https://api.scrapingdog.com/screenshot?api_key=#{api_key}&url=#{URI.encode_www_form_component(target_url)}")
# Create an HTTP GET request
request = Net::HTTP::Get.new(url)
# Create an HTTP client
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true # Enable SSL (https)
# Send the request and get the response
response = http.request(request)
# Check if the request was successful
if response.is_a?(Net::HTTPSuccess)
# The response body is raw PNG image bytes, save it to a file.
File.open('screenshot.png', 'wb') { |f| f.write(response.body) }
puts 'Screenshot saved to screenshot.png'
else
puts "HTTP request failed with code: #{response.code}, message: #{response.message}"
endconst axios = require('axios');
const fs = require('fs');
const api_key = '5eaa61a6e562fc52fe763tr516e4653';
const url = 'https://api.scrapingdog.com/screenshot';
const params = {
api_key: api_key,
url: 'https://www.scrapingdog.com/',
};
axios
.get(url, { params: params, responseType: 'arraybuffer' })
.then(function (response) {
if (response.status === 200) {
// The response body is raw PNG image bytes, save it to a file.
fs.writeFileSync('screenshot.png', Buffer.from(response.data));
console.log('Screenshot saved to screenshot.png');
} else {
console.log('Request failed with status code: ' + response.status);
}
})
.catch(function (error) {
console.error('Error making the request: ' + error.message);
});Capturing pixel-accurate screenshots by hand means running a headless-browser fleet and fighting flaky renders on each target.
Self-hosted Puppeteer or Playwright workers crash, leak memory, and drift out of date with each Chromium release.
Without tuned wait logic, you capture blank heroes and skeleton loaders before lazy images actually paint.
Reproducing a consistent viewport, retina DPI, and image format across machines is fiddly, so diffs flag false regressions.
Consent banners, region gates, and anti-bot challenges overlay the page, leaving your archive full of interstitials.
With Scrapingdog, one API call handles rendering, proxies, blocks, and scaling, returning a clean PNG image.
Capture pixel-perfect snapshots instantly to document and archive any web page the moment you need it.
Keep precise visual records of pages over time, making content review and management simple.
Pull HD screenshots straight into reports and dashboards without manual capture or editing.
A single API call returns a ready-to-use PNG, so you focus on your data instead of infrastructure.
Capture screenshots instantly with our API, which processes URLs in real time, delivering up-to-the-minute snapshots.
Our Screenshot API handles high-volume requests, capturing thousands of pages without slowing down.
Adhere to privacy standards with screenshots captured through a process that respects user privacy at every step.
A built-in rotating proxy changes IP addresses per request, so pages render just like they do for a real user.
Our powerful infrastructure delivers reliable captures every time, with optimized proxy rotation and headless rendering.
Every request returns a ready-to-use PNG image of the page, with no parsing required before you save it.
Capture pages on demand to confirm that content, layout, and messaging appear exactly as intended.
Snapshot competitor pages over time to track how their landing pages, offers, and design evolve.
Automatically archive web pages as precise visual records for compliance, legal, or historical reference.
Collect screenshots across pages and devices to study and compare real user experience at scale.
Verify that SEO elements and marketing campaigns render correctly across the pages you monitor.
Run regular captures to catch visual regressions and keep design consistent across your web properties.
Sign up and get free credits to start testing the Screenshot API.
Access your unique API key from the dashboard and use it to capture screenshots.
Call GET /screenshot with your api_key and the target url.
The response body is the raw PNG image. Write the bytes straight to a file.
Start your web scraping journey with 200 free credits. Test our service and upgrade to one of the plans below. Cancel anytime.

I got the free trial and in less than a minute I already integrated with their API to scrape Google, matter of fact they had all the plug-and-play codes ready for me, It was seamless. I am about to upgrade as I have used up my trial credits.
United States
I love how you can use it to scrape data from Google.
Oslo, Norway
Scrapingdog is an awesome service. I use it with my Local Leads Sniper system and thanks to it I have been able to land a few clients since it gave me all the info that my client's Google Business Profile was missing. Great service!
Mexico
Amazing service. I am using it for Google Maps reviews and it works perfectly. I have also used Live chat and they were very fast and punctual on responses. 100% recommended.
Italy
The Screenshot API allows you to programmatically capture real-time screenshots of web pages, offering a simple way to integrate webpage visualization into your applications.
Screenshots can be captured and delivered in PNG.
The API typically captures and delivers the screenshot as is, but you can use additional software or processing scripts to edit the images once you have received them.
The API captures the webpage as it is at the moment of the request. If the page content changes during the capture process, these changes may not be reflected in the screenshot unless another capture is initiated.
Get 200 free credits to spin the API. No credit card required!