Screenshotlayer Getting Started: API Key & First Request (2026)

Getting started overview

This guide outlines the essential steps to begin using the Screenshotlayer API. It covers account creation, obtaining your API access key, and executing a foundational request to capture a website screenshot. The process is designed for developers seeking to integrate automated screenshot functionality into their applications or workflows.

The Screenshotlayer API is a RESTful service that accepts HTTP GET requests. Authentication is managed via a unique access key provided upon account registration. This key is included as a query parameter in each API call. The service supports various customization options, such as specifying viewport dimensions, full-page captures, and delays before rendering, as detailed in the official Screenshotlayer documentation.

Here's a quick reference for the initial setup:

Create an account and get keys

To interact with the Screenshotlayer API, you must first register for an account. Screenshotlayer offers a free tier that includes 250 API requests per month, suitable for initial testing and development. Paid plans, starting at $9.99 per month, provide increased request volumes and additional features. You can review the available plans on the Screenshotlayer pricing page.

1. Navigate to the Signup Page: Go to the Screenshotlayer website and select a plan to begin the registration process.
2. Complete Registration: Provide the required information (e.g., email address, password) to create your account.
3. Access Dashboard: Upon successful registration and login, you will be redirected to your personal account dashboard.
4. Locate API Access Key: Your unique API access_key will be prominently displayed within your dashboard, often under a section labeled "API Access Key" or similar. This key is crucial for authenticating all your API requests.

It is recommended to keep your API key secure and avoid exposing it in client-side code or public repositories. For server-side applications, store the key as an environment variable or in a secure configuration management system. Best practices for API key management often involve using environment variables for sensitive credentials, as described in guides like the Google Cloud API key best practices documentation.

Your first request

Once you have your access_key, you can make your first API call. The Screenshotlayer API is accessed via a simple HTTP GET request to its API endpoint. The most basic request requires your access_key and the URL you wish to screenshot.

The base API endpoint is https://api.screenshotlayer.com/api/capture.

Here's how to construct a basic request using cURL, a common command-line tool for making HTTP requests:

curl "https://api.screenshotlayer.com/api/capture?
    access_key=YOUR_ACCESS_KEY_HERE&
    url=https://www.example.com"

Replace YOUR_ACCESS_KEY_HERE with the actual API key from your Screenshotlayer dashboard and https://www.example.com with the URL you intend to capture. When executed, this command will return the raw image data (e.g., PNG or JPG, depending on default or specified output format) directly in your terminal, or save it to a file if you redirect the output.

Example with output redirection (Linux/macOS)

curl "https://api.screenshotlayer.com/api/capture?
    access_key=YOUR_ACCESS_KEY_HERE&
    url=https://www.example.com"
    --output example_screenshot.png

This command saves the generated screenshot to a file named example_screenshot.png in your current directory.

Basic request with Python

For programmatic access, here's an example using Python's requests library:

import requests

ACCESS_KEY = "YOUR_ACCESS_KEY_HERE"
TARGET_URL = "https://www.example.com"

params = {
    'access_key': ACCESS_KEY,
    'url': TARGET_URL
}

api_endpoint = "https://api.screenshotlayer.com/api/capture"

try:
    response = requests.get(api_endpoint, params=params, stream=True)
    response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)

    with open('example_screenshot_python.png', 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Screenshot saved as example_screenshot_python.png")

except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

This Python script fetches the screenshot and saves it to a local file. The stream=True and iter_content approach is recommended for handling binary data like images efficiently, especially for larger files.

Common next steps

After successfully making your first screenshot request, consider these common next steps to further integrate and optimize your use of Screenshotlayer:

• Explore API Parameters: The Screenshotlayer API offers various parameters to customize your screenshots. These include viewport (to specify browser dimensions), fullpage (to capture the entire page), delay (to wait before capture), format (e.g., jpg, png), and more. Refer to the Screenshotlayer API documentation for a comprehensive list and examples.
• Error Handling: Implement robust error handling in your application to manage cases where the API might return an error (e.g., invalid URL, authentication failure, rate limits). The API typically returns JSON error responses that include an error code and description.
• Rate Limiting: Be aware of the rate limits associated with your chosen plan. Exceeding these limits can result in temporary blocks or failed requests. Implement retry mechanisms with exponential backoff if your application frequently encounters rate limit errors, a common practice described in various API integration guides, such as those for Stripe API rate limits.
• Integrate into Applications: Begin integrating the screenshot functionality into your specific application use case, such as generating social media preview images, archiving webpage content, or monitoring website changes.
• Consider SDKs/Client Libraries: While Screenshotlayer does not provide official SDKs, community-contributed wrappers or general HTTP client libraries (like requests in Python, axios in Node.js) can simplify API interactions.
• Upgrade Plan: If your usage exceeds the free tier or requires advanced features, consider upgrading to a paid plan on the Screenshotlayer pricing page.

Troubleshooting the first call

If your initial API call does not return a screenshot or results in an error, consider the following common troubleshooting steps:

• Check API Key: Ensure your access_key is correct and has not been truncated or mistyped. Verify it against the key displayed in your Screenshotlayer dashboard.
• Verify URL Encoding: The url parameter, like all query parameters, must be URL-encoded, especially if it contains special characters (e.g., ?, &, /, :). While cURL often handles basic encoding, programmatic clients might require explicit encoding functions. For example, in Python, use urllib.parse.quote_plus() for robust URL encoding.
• Examine Error Responses: If the API returns a JSON error instead of an image, carefully read the code and info fields in the response. These provide specific details about what went wrong. Common errors include:
• 101 - missing_access_key: Your API key is missing.
• 102 - invalid_access_key: Your API key is incorrect.
• 103 - invalid_api_function: You're calling an unsupported API function.
• 104 - usage_limit_reached: You've exceeded your monthly request limit.
• 301 - missing_url: The url parameter is missing.
• 302 - invalid_url: The provided URL is not valid or accessible.
• Internet Connectivity: Ensure your development environment has an active internet connection and can reach api.screenshotlayer.com.
• Firewall/Proxy Issues: If you're in a corporate network, firewalls or proxy servers might be blocking outbound API calls. Consult your network administrator if this is suspected.
• Review Documentation: Revisit the official Screenshotlayer API documentation for the exact parameter names and expected values.
• Test with a Simple URL: Start by testing with a very simple and publicly accessible URL (e.g., https://www.google.com) to isolate issues related to the target website's complexity.