ScreenshotAPI.net Getting Started: Quickstart Guide (2026)

Getting started overview

Integrating with ScreenshotAPI.net involves a sequence of steps designed to get the API operational quickly. The fundamental process includes creating an account, retrieving API credentials, and making an initial API call to confirm functionality. ScreenshotAPI.net offers a free tier that provides 100 screenshots per month, allowing developers to test the service without immediate financial commitment.

The API is designed as a RESTful service, which typically means it uses standard HTTP methods (GET, POST, PUT, DELETE) for operations and relies on URLs to access resources. This architecture is common among web services for its simplicity and broad compatibility with various programming languages and platforms. For an overview of REST principles, refer to the MDN Web Docs on REST.

This guide outlines the essential steps to make your first successful API request, covering account setup and basic API interaction. Further details on advanced features and configurations are available in the ScreenshotAPI.net documentation.

Here's a quick reference table for the getting started process:

Create an account and get keys

To begin using ScreenshotAPI.net, you must first create an account. This process typically involves navigating to the ScreenshotAPI.net homepage and selecting a sign-up option. During registration, you will usually provide an email address and create a password. Once registered and logged in, your API key will be accessible from your user dashboard.

The API key serves as your authentication credential for all API requests. It is a unique string that identifies your account and authorizes your usage of the service. API keys are a common method for authenticating requests in web APIs, as detailed in various Google Developers API key documentation.

Follow these steps to obtain your API key:

1. Navigate to the ScreenshotAPI.net website.
2. Click on the "Sign Up" or "Get Started Free" button.
3. Complete the registration form with your email and desired password.
4. Verify your email address if prompted.
5. Log in to your newly created account.
6. On your account dashboard, locate the section labeled "API Key" or "Credentials."
7. Copy the displayed API key. Keep this key secure, as it grants access to your ScreenshotAPI.net account and usage limits.

It is recommended to store your API key securely and avoid embedding it directly in client-side code where it could be exposed. For server-side applications, environment variables or secret management services are generally preferred methods for handling API keys.

Your first request

After obtaining your API key, you can make your first request to ScreenshotAPI.net. The API is accessed via a simple HTTP GET request to a specific endpoint, with parameters included in the URL query string. The primary parameters include your API key and the URL of the website you wish to screenshot.

The basic structure for a screenshot request URL is:

https://shot.screenshotapi.net/screenshot?token=YOUR_API_KEY&url=https://example.com

Replace YOUR_API_KEY with the key you retrieved from your dashboard and https://example.com with the target URL you want to capture. The API will return an image file (e.g., PNG or JPG), which you can then save or display.

Here are examples of how to make this request using common programming languages:

cURL Example

cURL is a command-line tool and library for transferring data with URLs, commonly used for testing API endpoints:

curl -o screenshot.png "https://shot.screenshotapi.net/screenshot?token=YOUR_API_KEY&url=https://www.apispine.com"

This command will save the generated screenshot as screenshot.png in your current directory.

Python Example

Using the requests library in Python:

import requests

api_key = "YOUR_API_KEY"
target_url = "https://www.apispine.com"

request_url = f"https://shot.screenshotapi.net/screenshot?token={api_key}&url={target_url}"

response = requests.get(request_url)

if response.status_code == 200:
    with open("screenshot.png", "wb") as f:
        f.write(response.content)
    print("Screenshot saved as screenshot.png")
else:
    print(f"Error: {response.status_code} - {response.text}")

Node.js Example

Using the built-in https module or a library like node-fetch (after npm install node-fetch):

const fetch = require('node-fetch'); // For Node.js versions that don't have native fetch
const fs = require('fs');

const apiKey = "YOUR_API_KEY";
const targetUrl = "https://www.apispine.com";

const requestUrl = `https://shot.screenshotapi.net/screenshot?token=${apiKey}&url=${targetUrl}`;

async function captureScreenshot() {
    try {
        const response = await fetch(requestUrl);

        if (response.ok) {
            const arrayBuffer = await response.arrayBuffer();
            fs.writeFileSync('screenshot.png', Buffer.from(arrayBuffer));
            console.log('Screenshot saved as screenshot.png');
        } else {
            const errorText = await response.text();
            console.error(`Error: ${response.status} - ${errorText}`);
        }
    } catch (error) {
        console.error('Network or fetch error:', error);
    }
}

captureScreenshot();

PHP Example

Using file_get_contents or cURL in PHP:

<?php
$apiKey = "YOUR_API_KEY";
$targetUrl = "https://www.apispine.com";

$requestUrl = "https://shot.screenshotapi.net/screenshot?token=" . $apiKey . "&url=" . urlencode($targetUrl);

$imageData = @file_get_contents($requestUrl);

if ($imageData !== FALSE) {
    file_put_contents("screenshot.png", $imageData);
    echo "Screenshot saved as screenshot.png\n";
} else {
    echo "Error: Could not retrieve screenshot. Check API key and URL.\n";
}
?>

After executing any of these examples, you should find a file named screenshot.png in your project directory containing the screenshot of https://www.apispine.com. This confirms a successful initial integration.

Common next steps

Once you have successfully made your first API call and confirmed that ScreenshotAPI.net is functioning, several common next steps can enhance your integration:

• Explore advanced parameters: The ScreenshotAPI.net documentation details various parameters to control screenshot output, such as image format (JPG, PNG), viewport dimensions, full-page capture, delay before capture, and custom CSS injection. Experimenting with these parameters can tailor the screenshots to specific application needs.
• Error handling: Implement robust error handling in your code to manage scenarios like invalid API keys, malformed URLs, or service unavailability. The API will return specific HTTP status codes and error messages that can be used for debugging.
• Rate limiting and usage monitoring: Understand the usage limits associated with your chosen plan. Implement logic to monitor your API usage and handle rate limits gracefully to avoid service interruptions.
• Asynchronous processing: For applications requiring many screenshots or where immediate synchronous responses are not critical, consider implementing asynchronous processing. This can involve queuing screenshot requests and processing them in the background, improving the responsiveness of your primary application.
• Security best practices: Ensure your API key is handled securely. Avoid hardcoding it directly into public repositories or client-side code. Use environment variables or secure credential management systems, especially in production environments. Learn more about Google Cloud API key best practices.
• Integration with other services: Consider integrating ScreenshotAPI.net with other tools in your development workflow. For example, you might combine it with cloud storage services (like AWS S3 or Google Cloud Storage) to store screenshots, or with CI/CD pipelines for automated visual regression testing.
• Upgrade your plan: If your application requires more than the free tier's 100 screenshots per month, evaluate the paid plans offered by ScreenshotAPI.net to accommodate increased usage.

Troubleshooting the first call

Encountering issues during the first API call is common. Here are some troubleshooting steps and common problems:

• Invalid API Key:
  • Symptom: The API returns an "Unauthorized" or "Invalid Key" error (e.g., HTTP 401 status code).
  • Solution: Double-check that you have copied the API key correctly from your ScreenshotAPI.net dashboard. Ensure there are no leading or trailing spaces.
• Incorrect URL Formatting:
  • Symptom: The API returns an error indicating a malformed URL or a blank/corrupted image.
  • Solution: Verify that the url parameter in your request is properly URL-encoded, especially if it contains special characters. Ensure it includes http:// or https://.
• Rate Limit Exceeded:
  • Symptom: The API returns a "Too Many Requests" error (HTTP 429 status code).
  • Solution: If you are on the free tier, you are limited to 100 screenshots per month. Wait for your quota to reset or consider upgrading your ScreenshotAPI.net plan.
• Network Issues:
  • Symptom: Your application reports a network timeout or inability to connect to the API endpoint.
  • Solution: Check your internet connection. If running from a server, ensure there are no firewall rules blocking outbound requests to shot.screenshotapi.net.
• Missing Output File:
  • Symptom: The code executes without an error, but no image file is saved.
  • Solution: Verify the file path and permissions for saving the screenshot. Ensure the directory exists and your application has write access.
• Generic API Error:
  • Symptom: The API returns a generic server error (e.g., HTTP 500 or 503).
  • Solution: This could indicate a temporary issue with the ScreenshotAPI.net service. Check the ScreenshotAPI.net status page (if available) or try the request again after a short delay. If the problem persists, consult the ScreenshotAPI.net documentation for specific error codes or contact support.

Always refer to the official ScreenshotAPI.net documentation for the most up-to-date error codes and troubleshooting guidance.