Use CaptureKit via MCP to Screenshot and Scrape the Web

AI agents are getting better at writing code, answering questions, and automating workflows. But there is one thing most of them still cannot do well: look at a live website.

They cannot take a screenshot of a page, extract its clean content, or scrape structured data from a URL — at least not without you writing the tooling yourself.

That changes with the CaptureKit MCP server.

What is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI assistants call external tools. Think of it as a plugin system for AI: instead of the model pretending it can browse the web, it calls a real tool that does the job and returns the result.

MCP clients include Claude, Cursor, Gemini CLI, and OpenAI Developer Mode. Each of them can connect to MCP servers and use the tools they expose.

CaptureKit now runs an MCP server at https://mcp.capturekit.dev/. Connect it once, and your AI assistant gains access to screenshots, content extraction, Markdown conversion, and web crawling — all via the same infrastructure that powers the REST API.

What CaptureKit exposes via MCP

The MCP server maps directly to CaptureKit's API endpoints. Your AI agent gets four tools:

1. Screenshot capture (/capture)

Capture a full-page or viewport screenshot of any URL and get back an image. Useful for:

• Reviewing a live page before making recommendations
• Documenting UI changes automatically
• Generating visual previews in documentation workflows
• Validating that a deployed page looks correct

2. Content extraction (/content)

Fetch the raw HTML, extracted text, metadata, and internal/external links from any URL. The agent gets structured, machine-readable data instead of a wall of HTML.

3. Markdown extraction (/content with include_markdown=true)

Get a clean Markdown version of any page. This is the most useful tool for AI workflows:

• Feed web content to LLMs without noise from scripts, styles, and navigation
• Build knowledge bases by extracting documentation pages
• Summarize competitor pages without manual copy-paste
• Ingest changelogs, release notes, and blog posts automatically

The Markdown output strips away everything that is not content: ads, cookie banners, sidebars, scripts. What remains is the actual text, structured with headings, lists, and links.

4. Website crawler (/crawler)

Crawl an entire domain and return structured data from multiple pages in one call. Instead of running the content tool page by page, the crawler discovers URLs and extracts content at scale.

Why use CaptureKit instead of doing it yourself?

A common instinct when building AI tooling is to write your own browser automation — a Playwright or Puppeteer script that navigates pages and returns content. This works for a demo, but breaks in production.

Here is what you run into:

Bot detection. Most websites with useful content actively block headless browsers. CAPTCHAs, fingerprinting, IP bans, and JavaScript challenges stop naive scrapers within hours. CaptureKit handles this layer so you do not have to.

Browser infrastructure. Running a headless browser at scale requires memory, CPU, and careful process management. Cold starts are slow. Crashes need recovery logic. None of this is trivial. CaptureKit abstracts the entire infrastructure away — you make an HTTP call and get a result.

JavaScript rendering. Static fetch() calls miss anything rendered client-side. CaptureKit always runs a real browser, so single-page apps, dynamic content, and lazy-loaded sections are all captured correctly.

Maintenance. Puppeteer APIs change. Chrome updates break things. Keeping a self-hosted scraper running over months is real engineering work. With CaptureKit you get a versioned API that stays stable.

Reliability. CaptureKit is built to be production-grade: consistent response times, proper error codes, and retry logic at the infrastructure level. You get the same quality from your 1st request and your 100,000th.

Setting it up in Cursor

Add the CaptureKit MCP server to your Cursor settings in one step. Go to Settings → MCP and add:

{
  "mcpServers": {
    "capturekit": {
      "url": "https://mcp.capturekit.dev/",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}

Replace YOUR_API_KEY with a key from your CaptureKit dashboard. That is the full setup.

From that point, Cursor can call CaptureKit tools directly in any conversation. You can ask it to take a screenshot of a URL, extract its content as Markdown, or crawl a site — and it will use CaptureKit to do it.

Setting it up in Claude Code

claude mcp add --transport http capturekit https://mcp.capturekit.dev/ --header "x-api-key: YOUR_API_KEY"

Same result: Claude Code now has access to CaptureKit tools in every session.

Practical examples

"Review this competitor's pricing page and summarize the plans"

Without MCP, the agent either makes something up or asks you to paste the content. With CaptureKit, it fetches the Markdown from the URL, reads the actual current content, and gives you a real answer.

"Take a screenshot of my staging environment and check if the hero section looks right"

The agent captures the page, inspects the image, and reports back. No manual browser switching, no copy-paste.

"Extract all the documentation from docs.example.com and build a knowledge base"

The crawler tool maps the domain and returns content from every page in a single structured response. The agent processes it and builds whatever you need.

"My deploy just shipped. Verify that the homepage still loads and looks correct"

A screenshot plus content extraction tells the agent whether the page is up, what it contains, and whether anything obvious looks broken. One tool call, one answer.

Who this is for

• Developers building AI agents that need to interact with live web content
• Founders using Claude or Cursor for competitive research without manual data collection
• Product teams automating documentation workflows
• Anyone tired of copy-pasting web content into an AI chat window

Get started

1. Create an account at app.capturekit.dev
2. Generate an API key
3. Add the MCP server to your AI client of choice
4. Ask your agent to fetch any URL

The MCP documentation has the exact configuration for Claude Code, Cursor, Gemini CLI, and OpenAI Developer Mode.

Your AI assistant now has eyes. Use them.