Screenshot API for Developers

A developer-first screenshot API with a clean REST interface, SDKs in 6 languages, and Chromium rendering that handles JavaScript, dynamic content, and modern CSS accurately.

Get API Key — Free

Developer Experience First

SnapAPI is designed for developers who want to integrate screenshot capture into their applications without fighting the API. The REST interface follows standard HTTP conventions: GET requests with URL and configuration as query parameters, Bearer token authentication via the Authorization header, binary image responses for screenshot and PDF endpoints, and JSON responses for scrape and extract endpoints. Error responses include a JSON body with a message field describing the error, making it straightforward to display human-readable errors in application logs. The API returns appropriate HTTP status codes: 200 for success, 400 for invalid request parameters with a description of the validation error, 401 for missing or invalid API keys, 429 for rate limit exceeded with a Retry-After header, and 500 for server-side rendering failures. This conventional HTTP behavior means any HTTP client in any language works with SnapAPI without surprises or special-case handling for non-standard response formats.

Screenshot API REST Endpoint Reference

SnapAPI provides four REST endpoints under the base URL https://api.snapapi.pics. The screenshot endpoint at GET /screenshot accepts url (required), format (png or jpeg, default png), quality (1-100 for JPEG, default 85), width (viewport width in pixels, default 1280), height (viewport height in pixels, optional), full_page (true or false, default false), and delay (milliseconds to wait before capture, default 0). The scrape endpoint at GET /scrape accepts url (required) and returns JSON with title, description, text, and html fields. The extract endpoint at GET /extract accepts url (required) and selector (CSS selector, required) and returns JSON with a matches array of element text content and outer HTML. The PDF endpoint at GET /pdf accepts url (required), format (paper size, default A4), margin_top, margin_bottom, margin_left, margin_right (millimeter values, default 10mm), landscape (true or false, default false), print_background (true or false, default false), and delay (milliseconds to wait, default 0). All endpoints authenticate via the Authorization: Bearer YOUR_API_KEY header.

# Quick start: all four endpoints
import requests

API = "https://api.snapapi.pics"
HDR = {"Authorization": "Bearer YOUR_API_KEY"}

# Screenshot
img = requests.get(API+"/screenshot", params={"url":"https://example.com","format":"png"}, headers=HDR)
open("shot.png","wb").write(img.content)

# Scrape
data = requests.get(API+"/scrape", params={"url":"https://example.com"}, headers=HDR).json()
print(data["title"], data["description"])

# Extract
links = requests.get(API+"/extract", params={"url":"https://example.com","selector":"a"}, headers=HDR).json()
print(links["matches"])

# PDF
pdf = requests.get(API+"/pdf", params={"url":"https://example.com","format":"A4"}, headers=HDR)
open("page.pdf","wb").write(pdf.content)

Official SDKs in 6 Languages

SnapAPI provides official open-source SDKs for JavaScript and Node.js, Python, Go, PHP, Swift, and Kotlin, all published to the standard package registry for each language and maintained at github.com/Sleywill. Each SDK wraps the four SnapAPI endpoints in typed functions with language-idiomatic parameter handling, error types, and documentation. The JavaScript SDK installs with npm install snapapi and exports async functions compatible with both CommonJS and ES modules. The Python SDK installs with pip install snapapi and provides synchronous and async client classes. The Go SDK installs with go get github.com/Sleywill/snapapi-go. The PHP SDK installs via Composer. The Swift SDK integrates via Swift Package Manager for iOS and macOS applications. The Kotlin SDK publishes to Maven Central for Android and backend Kotlin applications. All SDKs are MIT-licensed and accept pull requests for bug fixes and improvements.

Developer Support and Documentation

SnapAPI documentation at snapapi.pics/docs covers the complete API reference, authentication, error handling, all endpoint parameters, code examples in all six SDK languages, and guides for common integration patterns including CI/CD visual testing, thumbnail generation, and report automation. The documentation is kept current with any API changes and includes runnable code examples that developers can copy directly into their projects. For integration questions, the SnapAPI support team is reachable via the contact form at snapapi.pics/contact. For bug reports and SDK issues, open an issue on the relevant GitHub repository at github.com/Sleywill. Register at snapapi.pics/register for a free API key with two hundred requests per month and no credit card required to start building with SnapAPI immediately.

Screenshot API Authentication and Security

SnapAPI authenticates requests using Bearer tokens passed in the HTTP Authorization header. Include the header Authorization: Bearer YOUR_API_KEY on every request to the SnapAPI REST endpoints. Never include the API key as a URL query parameter, as query parameters appear in server access logs and browser history and can be inadvertently exposed. Never embed the API key in client-side JavaScript, mobile app source code, or other code that ships to end users. Store the API key in environment variables or a secrets manager in your backend application, and pass it to the SnapApiService at initialization time. Generate a new API key from the SnapAPI dashboard at snapapi.pics/dashboard if your current key is compromised, and update your application configuration to use the new key. Use separate API keys for development, staging, and production environments to isolate quota consumption and enable independent key rotation without affecting other environments.

Screenshot API Rate Limits and Best Practices

SnapAPI applies rate limiting to prevent individual accounts from consuming disproportionate API capacity. Rate limit responses return HTTP 429 Too Many Requests with a Retry-After header indicating the number of seconds to wait before retrying. Handle 429 responses explicitly in your integration code by reading the Retry-After header value and waiting the specified duration before retrying the request, rather than immediately retrying which will continue to receive 429 responses. For batch processing jobs that need to process large URL lists, implement a concurrency limit in your worker pool that spreads requests evenly through time rather than sending all requests in a burst. The Starter plan supports approximately five thousand requests per month in steady-state usage, while the Pro plan supports fifty thousand. For applications with unpredictable traffic spikes, contact the SnapAPI team to discuss rate limit adjustments for your account. Configure your integration to log 429 responses as warnings with the Retry-After value so you can identify patterns of rate limit encounters and adjust your request rate accordingly.

Start Building with SnapAPI Today

Register at snapapi.pics/register for a free API key in under a minute. No credit card required, no time limit, no feature restrictions on the free tier. The first API call can be working in your language of choice within five minutes using the REST endpoint directly or one of the six official SDKs. The SnapAPI documentation at snapapi.pics/docs includes quickstart guides for every SDK language with copy-paste examples that make the first integration straightforward. Join the community of developers using SnapAPI for screenshot generation, web scraping, data extraction, and PDF conversion in production applications, monitoring systems, CI/CD pipelines, and AI agent workflows worldwide.

Screenshot API Integration Checklist for Developers

Before shipping a SnapAPI integration to production, verify these integration quality criteria. The API key is stored in an environment variable or secrets manager and not committed to source control. The screenshot endpoint URL parameter is validated as an absolute HTTP or HTTPS URL before calling the API. The integration has an explicit request timeout of thirty to sixty seconds to prevent indefinite blocking on slow renders. Rate limit responses are handled by reading the Retry-After header and waiting the specified duration before retrying. Failed screenshots degrade gracefully with a placeholder image rather than propagating an error to end users. Screenshot generation is performed asynchronously in background workers or queues to avoid blocking the HTTP request thread. Generated screenshots are cached in object storage or Redis with appropriate TTLs to avoid redundant API calls. Usage is monitored with an alert when monthly consumption reaches eighty percent of the plan limit. The integration is tested with URLs that return 404 errors, redirect chains, and JavaScript-heavy SPAs to verify graceful handling of edge cases. Separate API keys are used for development, staging, and production environments. Register at snapapi.pics/register for your free API key and start building today.

Screenshot API Webhook and Event-Driven Integration

Event-driven architectures trigger screenshot capture in response to application events rather than user actions or scheduled timers. When a user publishes a new piece of content, a webhook consumer receives the publish event and enqueues a screenshot capture job for the newly published page URL, generating an og:image and a thumbnail for use in content listings. When a deployment pipeline completes, the deploy success event triggers screenshot capture of the deployed pages for visual regression comparison against the stored baseline screenshots. When a customer adds a URL to a monitoring list, the list-item-created event triggers an initial screenshot capture to establish the visual baseline for change detection monitoring. SnapAPI integrates into these event-driven workflows as the screenshot capture step in the event consumer, called synchronously if the event consumer runs as an async task or enqueued as a background job if the consumer needs to return quickly. All four SnapAPI endpoints fit naturally into event-driven architectures where the triggering event provides the URL and the consumer determines which endpoint and parameters to use based on event type. Register at snapapi.pics/register to start integrating SnapAPI into your event-driven workflows today.