# PagePixels MCP > PagePixels handles programmatic visual asset generation. It lets your AI agent take high-quality screenshots of live URLs or custom HTML content. You can also manage continuous monitoring by creating and updating scheduled capture configurations, all via simple tool calls. ## Overview - **Category:** productivity - **Price:** Free - **Tags:** pagepixels, screenshots, automation, ai-agents, mcp ## Description **PagePixels MCP Server: Visual Asset Generation for Your AI Agent** Listen, forget anything that sounds like a marketing pitch about 'unlocking potential.' This server gives your agent something much more practical: the ability to grab high-fidelity pictures of web content. It's not just taking JPEGs; it runs rendering code on live URLs or raw HTML blocks and captures those visuals for you. ### Instant Snapshots & Live Captures You wanna see what a page looks like right now? You can use `quick_snap` to take an immediate screenshot of any URL. Your agent hits the tool, drops a web address, and *bam*—you get a picture of it instantly. If you need more control than just the quick snap, you've got `quick_snap_with_options`. This one lets you specify advanced parameters. You can tell your agent exactly what viewport size to use or if you need the whole page scrolled out—not just the first visible fold. It gives you granular control over how that live URL is captured. ### Snapping Custom Code Sometimes, a webpage doesn't exist yet, or maybe you're testing a chunk of code locally. That’s where `snap_custom_html` comes in. You pass it raw HTML code—a block right there in the prompt—and it renders that code into an image snapshot for you. It bypasses the need to connect to a live web server, letting you visualize content directly from the source code. ### Managing Automated Monitoring (Scheduling) If you gotta monitor something over time—like checking if a price changed or if a banner broke—you don't wanna manually snap it every hour. You set up automated monitoring using scheduled configurations. This whole cycle is managed by four tools, keeping your agent in control of the entire process. First, you use `create_screenshot_config`. This tool sets up an entirely new, recurring job. You define the URL and the schedule—say, every midnight on Tuesdays—and it'll take automated screenshots for you. It’s how you build out continuous visual checks without writing any code. Need to look at what you already set up? `list_screenshot_configs` gives you a summary of all your scheduled jobs. You can see if they're active or if they've been deleted. If you want the full skinny on one specific job, you use `get_screenshot_config`. Just drop in the unique ID, and it spits out every detail about that single configuration. Change your mind? If the URL changes or you gotta shift the schedule but don't wanna delete everything, you can use `update_screenshot_config`. This modifies an existing job—changing its parameters without losing the whole setup. It’s safer than starting over. When the monitoring is done and you don't need those scheduled snaps anymore, you call `delete_screenshot_config`. That tool stops the automated process and cleans up that configuration record entirely. ## Tools ### create_screenshot_config Sets up a new scheduled job to automatically take screenshots of specified content. ### delete_screenshot_config Stops and removes an existing automated screenshot monitoring configuration. ### get_screenshot_config Retrieves the full details of one specific, saved screenshot configuration using its unique ID. ### list_screenshot_configs Shows a list and status summary of all active or deleted screenshot configurations you've set up. ### quick_snap Takes an immediate, quick screenshot of any given URL address. ### quick_snap_with_options Captures a screenshot of a URL while letting you specify advanced parameters like viewport size or full-page scrolling. ### snap_custom_html Renders and takes an image snapshot from a block of raw HTML code provided in the prompt, bypassing live web requests. ### update_screenshot_config Modifies settings on an existing screenshot configuration—like changing the URL or schedule without deleting it first. ## Prompt Examples **Prompt:** ``` Take a full page screenshot of https://example.com. ``` **Response:** ``` I have successfully requested a full page screenshot for https://example.com. ``` **Prompt:** ``` List all my screenshot configurations. ``` **Response:** ``` Here are all your active screenshot configurations in PagePixels. ``` **Prompt:** ``` Render this HTML and take a screenshot. ``` **Response:** ``` The HTML has been rendered and the screenshot is available at the provided URL. ``` ## Capabilities ### Capture Live URLs Your AI client can take an immediate screenshot of any specified web address using `quick_snap`. ### Snap Custom HTML Content It renders and captures images from raw, custom HTML code blocks using `snap_custom_html`. ### Manage Scheduled Captures You can create, read, update, and delete full screenshot configurations to run automated visual monitoring tasks. ### Execute Advanced Snaps The `quick_snap_with_options` tool lets you take screenshots while specifying advanced options like resolution or viewport size. ## Use Cases ### Tracking Competitor Layouts A marketing manager needs to monitor how a competitor's pricing page looks after every major update. They set up a monitoring job using `create_screenshot_config` for the target URL, and then use `list_screenshot_configs` periodically to check if the visual output has changed since yesterday. ### Visual QA of Edge Cases A developer needs to test how a complex component looks when it fails to load data. Instead of manually writing and running a full environment, they use `snap_custom_html` by feeding the agent the raw HTML structure that represents the error state. The agent captures the visual proof immediately. ### Auditing Landing Pages An ops engineer needs to verify that all regional landing pages load correctly at a specific, high resolution. They use `quick_snap_with_options` with defined dimensions and run it against the list of URLs, ensuring consistent visual checks across multiple endpoints. ### Debugging Broken Components A designer finds that a section of the site is misaligned. They ask their agent to take a focused screenshot using `quick_snap` on just the URL's main body, allowing them to pinpoint the exact visual break without needing developer access. ## Benefits - Eliminate manual browser captures. Instead of opening a browser, navigating to a URL, and hitting 'screenshot,' you just ask your agent to run `quick_snap`. It handles the whole thing in code. - Manage continuous monitoring without boilerplate code. Use `create_screenshot_config` to set up scheduled jobs that automatically capture changes on competitor pages or live endpoints. - Test tricky states easily. When you need a mockup of an error message or empty cart state, use `snap_custom_html`. You feed it the raw HTML, and you get the image instantly—no dev environment needed. - Control the output every time. The `quick_snap_with_options` tool lets you specify resolution and viewport size in a single call, so your visual tests are always consistent. - Keep track of everything. If you need to see what configurations are running or if they failed, use `list_screenshot_configs`. It gives you a central status board for all your automated captures. ## How It Works The bottom line is: you ask your AI client for a visual asset, it uses PagePixels tools to render and capture it, and you get the output in a single step. 1. First, grab your API token from PagePixels and add it to the integration settings for your AI client. 2. Next, prompt your agent. You can ask it to run a simple snap (e.g., 'Screenshot of X') or manage configs (e.g., 'List all my screenshot configurations'). 3. The server executes the tool call, renders the visual data, and sends the resulting image URL or configuration status back to your agent. ## Frequently Asked Questions **How do I schedule recurring screenshots using create_screenshot_config?** You use `create_screenshot_config` and must provide the target URL, desired frequency (e.g., hourly), and resolution parameters in the payload. The server then manages the job lifecycle for you. **What's the difference between quick_snap and quick_snap_with_options?** `quick_snap` is for fast, default captures of a URL. Use `quick_snap_with_options` when you need to guarantee specific parameters—like setting the viewport size or ensuring full-page scrolling—so your results are consistent. **Can I update an existing config without losing its history?** Yes, that's what `update_screenshot_config` is for. You pass the configuration ID and only send the parameters you want to change (like a new URL or schedule). The original setup remains intact. **Do I need an API key to use snap_custom_html?** Yes, your AI client needs the PagePixels API token. This verifies that you have permission to run rendering jobs and provides the credentials needed for the server to process the HTML. **If I use `quick_snap` and the target URL fails or returns an error code, how does the API report it?** The API detects the failure immediately and sends back a detailed HTTP status response. It includes the specific error message and the corresponding exit code from the failing site, letting you know exactly what went wrong. **Using `list_screenshot_configs`, what key metadata points are returned for each saved configuration?** The tool returns a list containing the unique config ID, the scheduled URL, and the last successful run time. This lets you quickly audit which capture settings are active or haven't been updated. **What should I do if I encounter permission issues when trying to execute `delete_screenshot_config`?** You must verify that your API token possesses write access permissions for configuration management. If deletion fails due to rights, check the integration scope settings in Vinkius. **When using `quick_snap_with_options`, what parameters control the resolution and viewport size?** You pass specific JSON arguments defining these constraints. This lets you set the exact pixel dimensions, scale factor, or desired viewport area for precise image generation. **Does the AI agent store the screenshots?** No, the AI agent uses PagePixels to generate the screenshots, which are stored securely by the PagePixels service and provided as URLs to the agent. **Can I capture full pages?** Yes! The AI agent can use advanced options to instruct PagePixels to capture the entire height of the webpage. **Are there limits on screenshot generation?** Limits depend strictly on your active PagePixels subscription plan.