# ScreenshotAPI MCP

> ScreenshotAPI captures full-page website screenshots programmatically through an API. It lets your AI agent simulate specific devices—like iPhone or Android—and capture visuals under various conditions: dark mode, ad-free, or high-resolution WebP. You can even convert entire pages to professional PDFs.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** screenshotapi, website-screenshot, pdf-generation, mobile-emulation, visual-qa, full-page-capture, ad-blocking, rendering-api, mcp

## Description

You'll connect this server to your agent and instantly get full visual control over any website. This API lets you take pixel-perfect screenshots, simulate specific devices, or turn whole pages into professional PDFs—it's built for getting visuals right, every time.

Need to see what the site looks like on a phone? You can use `capture_mobile_view_screenshot` to capture exactly what an iPhone or Android user sees, setting specific viewport sizes and resolutions. If you need something quick and just want a standard shot of the page, run `capture_website_screenshot`; it gives you a basic snapshot link right away. But if that isn't enough—and usually it isn't—you might need to capture only one small part of the layout. With `capture_specific_element`, you define a CSS selector and your agent grabs just that precise area, ignoring all the surrounding junk.

When dealing with live websites, things break or load slow. If content pops in later because of lazy loading scripts, don't trust a quick capture; run `capture_delayed_screenshot` to force your agent to wait for a set time before grabbing the image. You might also need the entire page—not just what fits on one screen. Use `capture_full_length_screenshot`, and it scrolls automatically until it captures every bit of content, ensuring nothing gets cut off.

You're always worried about ads or cookie banners messing up your shots, right? To get a genuinely clean image, use `capture_clean_screenshot_no_ads`. It blocks those annoying pop-ups and ad banners so you only see the core product. If you need to know what the site looks like in a different mood, run `capture_dark_mode_screenshot` to force the entire page into dark mode. For absolute certainty that your shot isn't using stale data, use `capture_new_screenshot_no_cache`; this tells the API to ignore any local browser cache and pull genuinely fresh visual info.

Formatting options are huge too. You can save an entire live webpage as a single, formatted document with `convert_webpage_to_pdf`. If you don't need PDF, but want modern image quality, use `capture_webp_format_screenshot` to generate the output in WebP format instead of standard PNG or JPEG. The API also gives you visibility into its own status; run `check_api_health` to verify that the service is up and running when you need it most. You'll also want to track your usage, so `get_api_quota_info` lets you check your remaining call limits.

## Tools

### capture_clean_screenshot_no_ads
Captures a screenshot of a URL while automatically blocking cookie banners and advertisements.

### capture_dark_mode_screenshot
Takes a full-page screenshot with the site's color scheme forced into dark mode.

### capture_delayed_screenshot
Captures a screenshot after waiting for a specified time, useful when content loads via lazy loading.

### capture_new_screenshot_no_cache
Forces the API to ignore local browser cache, ensuring you get genuinely fresh visual data.

### capture_full_length_screenshot
Captures the entire vertical length of a webpage, scrolling automatically to get all content.

### capture_mobile_view_screenshot
Takes a screenshot using a specific mobile device viewport size and resolution.

### convert_webpage_to_pdf
Saves an entire live webpage into a single, formatted PDF document file.

### capture_specific_element
Captures only a precise area of a webpage defined by its CSS selector, ignoring surrounding content.

### capture_website_screenshot
Captures a standard, default-sized screenshot of any provided URL and returns a hosted link.

### capture_webp_format_screenshot
Generates the screenshot output file in the modern WebP image format instead of PNG or JPEG.

### check_api_health
Verifies the current operational status and uptime of the ScreenshotAPI service itself.

### get_api_quota_info
Retrieves your current account usage metrics and remaining API call limits for tracking purposes.

## Prompt Examples

**Prompt:** 
```
Take a clean mobile screenshot of the Apple homepage (https://www.apple.com) without any cookie banners or ads.
```

**Response:** 
```
I've successfully captured a clean mobile viewport screenshot of the Apple homepage. All cookie consent banners and overlays were blocked. You can view the final image here: https://screenshotapi.net/storage/apple-mobile-clean.png
```

**Prompt:** 
```
Capture a full-length screenshot of the Stripe pricing page (https://stripe.com/pricing) to check their new tier layout.
```

**Response:** 
```
The full-page capture is complete. I scrolled from top to bottom to render the entire Stripe pricing page accurately. Here is the full-length high-resolution image: https://screenshotapi.net/storage/stripe-pricing-full.png
```

**Prompt:** 
```
Generate a professional PDF export of the latest Y Combinator blog post at https://blog.ycombinator.com/yc-top-companies-2024.
```

**Response:** 
```
I've converted the Y Combinator blog post into a high-quality PDF document. The formatting and typography have been preserved perfectly. You can download the PDF report here: https://screenshotapi.net/storage/yc-top-companies-2024.pdf
```

## Capabilities

### Capture Full Page Views
Captures the entire visible length of a webpage using tools like `capture_full_length_screenshot`, ensuring nothing gets cut off.

### Simulate Device Viewports
Takes screenshots as if they were viewed on specific devices (e.g., iPhone, Android) with the `capture_mobile_view_screenshot` tool.

### Generate Clean Assets
Captures visuals without distracting elements like ad banners or cookie pop-ups using `capture_clean_screenshot_no_ads`.

### Format to PDF/WebP
Converts a live webpage into downloadable PDF documents (`convert_webpage_to_pdf`) or modern WebP image files (`capture_webp_format_screenshot`).

### Isolate Elements
Focuses the capture on one specific section of code, ignoring everything else using `capture_specific_element`.

## Use Cases

### Checking Competitor Layouts
A marketing manager wants to compare two competitor product pages. They ask their agent: 'Capture the homepage for both sites on mobile viewports, making sure you block any ads or cookie banners.' The agent runs `capture_mobile_view_screenshot` and then chains it with `capture_clean_screenshot_no_ads`, delivering two clean, side-by-side images.

### Archiving Research
A researcher needs to document the current state of a web page for internal records. They ask their agent: 'Convert this article into a PDF report.' The agent uses `convert_webpage_to_pdf`, saving hours compared to printing and manually organizing files.

### Debugging Hidden Content
A dev team suspects an element only loads after a delay. They ask the agent: 'Check this page, but wait 3 seconds first.' The agent executes `capture_delayed_screenshot`, capturing the content *after* the slow-loading script runs, solving the mystery.

### Creating Minimalist Reports
A product manager needs a clean visual of just a pricing table for a slide deck. They don't want headers or footers. The agent uses `capture_specific_element` with the CSS selector for the pricing table, getting a perfectly isolated image.

## Benefits

- **Cross-Device Reliability:** Stop guessing how a site looks on different phones. Use `capture_mobile_view_screenshot` to guarantee your design holds up across standard mobile viewports.
- **Zero Ad Clutter:** Get clean visuals every time. The `capture_clean_screenshot_no_ads` tool blocks cookie banners and pop-ups, making sure the screenshot you receive is the actual content, not the marketing overlay.
- **Full Context Capture:** Don't just grab a visible window. Use `capture_full_length_screenshot` to scroll through an entire article or pricing page in one go.
- **Professional Deliverables:** Instead of screenshots, sometimes you need documents. Run `convert_webpage_to_pdf` to turn any web content into a universally accepted PDF report.
- **Debugging Specificity:** Need the corner widget? Use `capture_specific_element`. This tool lets your agent target visuals by CSS selector—it's surgical, not broad.

## How It Works

The bottom line is: you stop clicking in browser developer tools. You just tell your agent what visual data you need, and it runs the necessary API calls for you.

1. Subscribe to this server and provide your ScreenshotAPI.net token in the client configuration.
2. In a natural language prompt, tell your AI agent exactly what you need (e.g., 'Capture the Apple homepage on mobile, dark mode, and block ads').
3. The agent executes one or more specific tools (like `capture_mobile_view_screenshot` followed by `capture_clean_screenshot_no_ads`) and returns a direct link to the resulting image or PDF.

## Frequently Asked Questions

**How do I make sure my screenshot captures everything on a long page?**
Use the `capture_full_length_screenshot` tool. This automatically simulates scrolling from top to bottom, guaranteeing you get every part of the content without manual intervention.

**Does capture_clean_screenshot_no_ads work on all types of pop-ups?**
It blocks common elements like ad banners and cookie consent modals. For specific overlay issues, you might need to combine it with a delay tool or use `capture_specific_element` to target only the main content area.

**I want an image that looks professional for printing; what format should I use?**
Use `convert_webpage_to_pdf`. This reliably saves the entire page layout into a single PDF document, preserving fonts and structure better than a screenshot.

**How do I capture just one small widget on a large site?**
Run `capture_specific_element` and pass it the CSS selector for that widget. This isolates the element entirely, giving you a clean crop without capturing surrounding noise.

**Is there a tool to check if my API access is working?**
Yes, use `check_api_health`. This tool confirms the service is up and running before you start building complex workflows with other capture functions.

**How does running `get_api_quota_info` help me manage my usage limits?**
It immediately tells you your current API consumption status. This tool retrieves real-time data on your remaining quota and historical usage metrics, so you never hit an unexpected rate limit while working.

**If a website updates frequently, how should I use `capture_new_screenshot_no_cache` to ensure fresh results?**
Running this tool forces the capture engine to bypass any stored cache data. This means your AI client always gets a genuinely current version of the webpage, which is essential for accurate visual QA.

**When dealing with slow or lazy-loading sites, how does `capture_delayed_screenshot` help?**
It waits for a specified duration before taking the picture. This delay allows dynamic elements—like pop-ups or images that load slowly—to fully render on the page before the capture is executed.

**Can my AI automatically generate a PDF from a website URL?**
Yes! Use the `capture_pdf` tool. Provide the URL, and your agent will return a professional PDF document of the web page instantly.

**How do I take a screenshot specifically for mobile viewports?**
Simply ask the agent to run the `capture_mobile` action. It will automatically configure the viewport to 375x812 pixels to simulate a modern smartphone screen.

**How do I find my ScreenshotAPI.net Token?**
Log in to your ScreenshotAPI.net dashboard, and you will find your unique Token in the **API Key** section of your account settings.