Automate visual QA, capture any device state, or generate clean PDFs.
Claude
ChatGPT
Cursor
Gemini
Windsurf
VS Code
JetBrains
Vercel
Works with every AI agent you already use
…and any MCP-compatible client








Connect to your AI in seconds.
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.
What your AI can do
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.
Captures the entire visible length of a webpage using tools like capture_full_length_screenshot, ensuring nothing gets cut off.
Takes screenshots as if they were viewed on specific devices (e.g., iPhone, Android) with the capture_mobile_view_screenshot tool.
Captures visuals without distracting elements like ad banners or cookie pop-ups using capture_clean_screenshot_no_ads.
Converts a live webpage into downloadable PDF documents (convert_webpage_to_pdf) or modern WebP image files (capture_webp_format_screenshot).
Focuses the capture on one specific section of code, ignoring everything else using capture_specific_element.
Ask an AI about this
Compatible AI Apps
OAuth 2.0 CompatibleWaiting for input…
ScreenshotAPI MCP Server: 12 Tools for Visual Data
Access all tools to perform complex visual captures: from full-length page screenshots to targeted element isolation, and PDF conversion.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using ScreenshotAPI on VinkiusCapture 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...
Capture New Screenshot No Cache
Forces the API to ignore local browser cache, ensuring you get genuinely fresh...
Capture Full Length Screenshot
Captures the entire vertical length of a webpage, scrolling automatically to get all...
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...
Capture Website Screenshot
Captures a standard, default-sized screenshot of any provided URL and returns a...
Capture Webp Format Screenshot
Generates the screenshot output file in the modern WebP image format instead of PNG...
Check Api Health
Verifies the current operational status and uptime of the ScreenshotAPI service...
Get Api Quota Info
Retrieves your current account usage metrics and remaining API call limits for tracking purposes.
Connect to your AI in seconds. Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with ScreenshotAPI, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,000+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by ScreenshotAPI. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 12 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manually capturing website visuals is a huge waste of time.
Think about the old way: You open the browser, you switch tabs to check mobile view, you right-click and screenshot, but then you realize that specific section was covered by an ad banner. Then you repeat the whole process on a different device emulator—it’s click-heavy, tedious, and prone to human error.
With this MCP server, the process flips entirely. You just tell your agent: 'Show me how this page looks on an iPhone in dark mode without any ads.' The API handles the switching, the waiting (via `capture_delayed_screenshot`), and the cleaning—and you get a clean link back.
The ScreenshotAPI MCP Server delivers visual data from chat.
Previously, if you needed to validate content across multiple states (e.g., mobile vs. desktop, or light mode vs. dark mode), you had to run a sequence of manual checks in the browser. This meant jumping between tools and constantly checking for consistency.
Now, your agent runs it all through API calls—it handles the device emulation via `capture_mobile_view_screenshot` while simultaneously ensuring ad blocks are active. It's one command that gives you multiple verified assets.
What your AI can actually do with this
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.
019dd155-b445-710b-8cec-e41deff8a0fa Here's how it actually 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.
Subscribe to this server and provide your ScreenshotAPI.net token in the client configuration.
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').
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.
Who is this actually for?
QA engineers who hate manual cross-browser testing; marketing managers needing instant competitor asset retrieval; or content developers who constantly build reports based on live web pages. If your job involves checking how a website looks in five different states, this is for you.
Runs automated responsive design tests across multiple devices and viewports by chaining together tools like capture_mobile_view_screenshot and capture_full_length_screenshot.
Quickly gets visual snapshots of competitor landing pages or campaigns without opening a browser, using the clean capture provided by capture_clean_screenshot_no_ads.
Generates professional, formatted PDF reports from web content directly into the chat, bypassing manual export steps with convert_webpage_to_pdf.
What Changes When You Connect
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.
See it in action
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.
The honest tradeoffs
Relying on Generic Captures
Asking the AI to simply 'take a screenshot of this URL.' This often captures only the visible portion of the screen, ignoring full-page content or device differences.
If you need all the content, use capture_full_length_screenshot. If you need it on an iPhone, use capture_mobile_view_screenshot instead. Always specify your state requirement.
Ignoring Ad Overlays
Running a standard capture and getting a messy image covered by cookie pop-ups or ad banners. You then waste time trying to crop the garbage out.
Use capture_clean_screenshot_no_ads. This tool makes sure your captured visual is clean, giving you reliable results every single time.
Forgetting Format Control
Receiving a PNG image when the design team specifically asked for WebP or PDF. You then have to manually convert and re-upload files.
Specify your output format immediately. Use capture_webp_format_screenshot for modern web assets, or convert_webpage_to_pdf if it's a document.
When It Fits, When It Doesn't
Use this server if your primary bottleneck is visual data capture—specifically when you need to validate how content looks across different devices, states (dark mode, clean), or formats (PDF/WebP). Use it when the output must be pixel-perfect and repeatable.
Don't use this if you just need raw text extraction from a page; those are better handled by dedicated scraping tools that return Markdown or plain text. Also, don't use it for simple data retrieval (like checking user names); stick to tools designed for API endpoints. This tool is purely for visual assets.
Questions you might have
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.
We've already built the connector for ScreenshotAPI. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 12 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.