Screenshot Getting Started: API Integration Guide (2026)

Getting started overview

This guide provides a structured approach to initiating integration with the Screenshot API, covering account creation, API key retrieval, and the execution of a foundational API request. The Screenshot API is designed to capture website content programmatically, offering features such as full-page capture, custom resolutions, and device emulation Screenshot API documentation. Developers can utilize this functionality for various purposes, including website archiving, automated thumbnail generation, and monitoring changes to web pages.

The process begins with establishing an account to secure the necessary authentication credentials. Subsequently, developers will perform a basic API call to validate the setup. This initial request serves as a confirmation that the API key is correctly configured and that the development environment can communicate with the Screenshot API endpoints.

The following table summarizes the key steps:

Create an account and get keys

To begin using the Screenshot API, an account is required to generate and manage API keys. The API key serves as the primary method for authenticating requests and is essential for accessing the service. Screenshot API offers a free tier allowing 100 screenshots per month, which can be used for initial testing and development Screenshot API pricing details.

1. Navigate to the Signup Page: Go to the Screenshot API homepage and locate the 'Sign Up' or 'Get Started Free' option.
2. Complete Registration: Provide the necessary information, such as an email address and password, to create your account. Follow any instructions for email verification.
3. Access Dashboard: After successful registration and login, you will be directed to your account dashboard.
4. Locate API Key: Within your dashboard, find the section labeled 'API Key' or 'Developer Settings.' Your unique API key will be displayed there. Copy this key, as it will be used in all API requests.

It is recommended to store your API key securely and avoid hardcoding it directly into your application's source code. Environment variables or a secure configuration management system are preferred methods for handling API keys in production environments Google Cloud API key best practices.

Your first request

After obtaining your API key, the next step is to make a basic request to the Screenshot API to confirm that your setup is operational. The API is accessible via a RESTful interface, supporting standard HTTP methods. The primary endpoint for capturing screenshots typically involves sending a GET request with parameters specifying the target URL and your API key.

The Screenshot API provides SDKs for several programming languages, including Node.js, Python, Ruby, PHP, Go, Java, C#, and Rust. These SDKs simplify the process of constructing API requests and handling responses Screenshot API SDK documentation. For this first request, we will demonstrate using cURL, a command-line tool for making HTTP requests, and then provide examples for Node.js and Python.

Using cURL

Replace YOUR_API_KEY with your actual API key and example.com with the URL you wish to capture.

curl "https://shot.screenshotapi.net/screenshot?token=YOUR_API_KEY&url=https://example.com&width=1920&height=1080&full_page=true"

This cURL command requests a full-page screenshot of https://example.com at a resolution of 1920x1080 pixels. The API will return a JSON object containing a URL to the captured image.

Using Node.js

First, ensure Node.js is installed. Then, you can use a library like node-fetch or the built-in https module.

const fetch = require('node-fetch');

const apiKey = 'YOUR_API_KEY';
const targetUrl = 'https://example.com';

async function captureScreenshot() {
  try {
    const response = await fetch(`https://shot.screenshotapi.net/screenshot?token=${apiKey}&url=${targetUrl}&width=1920&height=1080&full_page=true`);
    const data = await response.json();
    console.log('Screenshot URL:', data.screenshot);
  } catch (error) {
    console.error('Error capturing screenshot:', error);
  }
}

captureScreenshot();

Before running, install node-fetch if you haven't already: npm install node-fetch.

Using Python

Ensure Python is installed. The requests library is commonly used for HTTP requests.

import requests

api_key = 'YOUR_API_KEY'
target_url = 'https://example.com'

def capture_screenshot():
    try:
        params = {
            'token': api_key,
            'url': target_url,
            'width': 1920,
            'height': 1080,
            'full_page': 'true'
        }
        response = requests.get('https://shot.screenshotapi.net/screenshot', params=params)
        response.raise_for_status()  # Raise an exception for HTTP errors
        data = response.json()
        print('Screenshot URL:', data.screenshot)
    except requests.exceptions.RequestException as e:
        print(f'Error capturing screenshot: {e}')

if __name__ == '__main__':
    capture_screenshot()

Install the requests library if needed: pip install requests.

Upon successful execution, the API will return a JSON response that includes a URL where the generated screenshot image can be accessed. This URL typically points to a temporary resource that stores the image file.

Common next steps

After successfully making your first API call, you can explore additional features and integrate the Screenshot API more deeply into your applications:

1. Explore Customization Options: The Screenshot API offers various parameters to customize screenshots, such as setting specific resolutions, enabling full-page captures, emulating different devices (e.g., mobile, tablet), and delaying the capture to allow page elements to load Screenshot API customization options. Experiment with these parameters to achieve the desired output for your specific use case.
2. Error Handling: Implement robust error handling in your application to manage potential issues such as invalid API keys, incorrect URLs, or API rate limits. The API typically returns descriptive error messages in its JSON responses.
3. Asynchronous Processing: For applications requiring high volumes of screenshots or long-running captures, consider implementing asynchronous processing patterns. This can involve using webhooks if supported by the API, or a queuing system, to avoid blocking your application while waiting for screenshot generation MDN Web Workers API overview.
4. Storage and Management: Decide how to store and manage the captured screenshots. The API provides a URL to the image, but you may need to download and store these images in your own cloud storage (e.g., AWS S3, Google Cloud Storage) for long-term retention or specific access patterns.
5. Security Best Practices: Review and implement security best practices for API key management, ensuring that your API key is not exposed in client-side code or public repositories. Consider using environment variables or a secrets management service.
6. Monitor Usage: Regularly check your API usage against your plan limits to prevent interruptions in service. Your Screenshot API dashboard typically provides usage statistics.

Troubleshooting the first call

Encountering issues during the initial API call is common. Here are some troubleshooting steps:

• Invalid API Key: Double-check that the API key used in your request exactly matches the key provided in your Screenshot API dashboard. Even minor typos can lead to authentication failures.
• Incorrect Endpoint: Verify that you are sending requests to the correct API endpoint. Refer to the Screenshot API documentation for the exact URL structure.
• Missing Parameters: Ensure all required parameters, such as token and url, are included in your request. Optional parameters might also have specific requirements.
• URL Encoding: If your target URL contains special characters, ensure it is properly URL-encoded. Libraries like Python's requests or Node.js's URLSearchParams handle this automatically, but manual encoding might be necessary for cURL or custom HTTP clients.
• Network Issues: Confirm that your development environment has an active internet connection and is not blocked by a firewall or proxy from accessing shot.screenshotapi.net.
• Rate Limits: Although less likely on a first call, be aware of API rate limits. If you make too many requests in a short period, subsequent requests might be temporarily denied. Check your dashboard for current limits.
• Check API Response: Always examine the full API response, including HTTP status codes and any JSON error messages. These messages often provide specific details about what went wrong. Common HTTP status codes include 200 OK for success, 400 Bad Request for malformed requests, 401 Unauthorized for invalid API keys, and 500 Internal Server Error for server-side issues.
• Consult Documentation: The Screenshot API documentation is the authoritative source for API specifications, error codes, and examples. Reviewing it can often resolve common integration challenges.