Skip to content

MCP

Screenshot and Markdown MCP server

ScreenshotOne provides a hosted MCP server that lets compatible AI agents connect to ScreenshotOne securely with OAuth. You do not need to run a local server or copy your ScreenshotOne API key into the MCP client.

  1. Create a ScreenshotOne account, or sign in to your existing account.

  2. Follow your client’s setup guide below to add this Streamable HTTP server:

    https://mcp.screenshotone.com
  3. Complete ScreenshotOne’s OAuth authorization in the browser, then return to your client.

  4. Confirm that the client discovers render-website-screenshot, render-website-screenshot-as-file, render-html-screenshot-as-file, extract-website-markdown, and get-usage.

Use the root URL exactly as shown, without adding /mcp or /sse. The client must support remote HTTP MCP and OAuth.

ClientSetup guide
ClaudeAdd a remote custom connector
Claude CodeAdd the HTTP server and authenticate
ChatGPTCreate a developer-mode MCP connection
CodexConfigure MCP and sign in
CursorConfigure mcp.json and connect
VS CodeAdd the server and enable its tools
Grok BotConnect with Streamable HTTP and OAuth
HarveyAdd a custom MCP connector
Hermes AgentConfigure remote MCP with OAuth
OpenClawUse native MCP and OAuth
MuseConnect with Streamable HTTP and OAuth
Another clientCheck compatibility and connect

After connecting, send this prompt:

Use ScreenshotOne's render-website-screenshot tool to capture
https://example.com with full_page=true. Show me the returned image URL
and download the image as example-screenshot.jpg if you can save files.

The corresponding tool arguments are:

{
"url": "https://example.com",
"full_page": true
}

A successful response contains a url. This is an illustration of the response shape, not a working download link:

{
"url": "https://files.screenshotonecache.com/example-screenshot.jpg"
}

Open the actual returned URL to inspect the image. If your client can download files, ask it to save the image and confirm the saved path. Otherwise, open the link in your browser and save it, or download it from a terminal:

Terminal window
curl --fail --location 'PASTE_THE_RETURNED_URL_HERE' --output example-screenshot.jpg

The URL lasts up to four hours. The MCP response contains a link rather than image bytes, so an agent must retrieve the image before it can inspect the pixels. Saving the link alone does not preserve the screenshot.

Start with a public URL. ScreenshotOne renders in its own browser and does not inherit your client’s signed-in browser session. For a long page, add full_page_slices:true so the agent can inspect smaller sections. See the options below.

Each tool’s description tells the agent when to use it, so agents usually pick the right one. If you name a tool in a prompt, pick it by what you have and what you need:

You haveYou needTool
A public URLA link to the screenshotrender-website-screenshot
A public URLThe screenshot or PDF file itselfrender-website-screenshot-as-file
HTML without a public URL, for example a page on localhost or behind a loginAn image the agent can seerender-html-screenshot-as-file
A public URLThe page text as Markdownextract-website-markdown

When the page is publicly reachable, pass its URL rather than its HTML. The page then renders exactly as the site serves it, and the agent doesn’t have to copy the HTML into the call.

Renders a website screenshot and returns a compact temporary URL instead of embedding the image in the MCP response.

The tool accepts the following options:

  • url: The HTTP or HTTPS URL to capture.
  • block_banners: Blocks cookie, GDPR, and similar banners and popups. The default is true.
  • block_ads: Blocks advertisements. The default is true.
  • image_quality: Sets the image quality from 1 to 100. The default is 80.
  • full_page: Captures the entire page instead of only the visible viewport. The default is false.
  • full_page_slices: Splits a full-page screenshot into smaller vertical images. The default is false and it requires full_page=true.
  • metadata_content: Extracts page content with the screenshot and returns it through a temporary URL. The default is false.
  • metadata_content_format: Chooses html or markdown for metadata_content. It requires metadata_content=true; the ScreenshotOne API default is html.

These option names and values match the ScreenshotOne API options. ScreenshotOne API response-type and cache controls are not exposed as MCP tool options. The server always requests a JSON response with API caching disabled.

For a screenshot and Markdown content in the same render, use:

{
"url": "https://example.com",
"metadata_content": true,
"metadata_content_format": "markdown"
}

The returned content object contains the temporary Markdown URL and its expiration time. The Markdown is not embedded in the screenshot tool response.

For a long page that an AI agent needs to analyze visually, prefer full_page_slices=true together with full_page=true. Smaller slices are more reliable for agent vision than one unusually tall image.

A call using both features returns:

{
"url": "https://files.screenshotonecache.com/screenshot.jpg",
"content": {
"url": "https://files.screenshotonecache.com/content.md",
"expires": "Sun, 07 Sep 2026 12:00:00 GMT",
"format": "markdown"
},
"slices": [
{
"index": 0,
"offset_y": 0,
"width": 1280,
"height": 4000,
"url": "https://files.screenshotonecache.com/slice-0.jpg"
}
]
}

The screenshot URL is temporary and is available for up to four hours. Content and slice URLs are also temporary. Download any artifact you need to keep.

Renders a website screenshot or PDF and returns the file itself, embedded in the MCP response as a resource, together with a temporary URL. Use it when you want to save or attach the file, or when your client can’t download links, for example Harvey. When a link is enough, render-website-screenshot keeps responses small.

The tool accepts the following options:

  • url: The HTTP or HTTPS URL to capture.
  • format: jpg (the default), png, webp, gif, jp2, tiff, avif, heif, or pdf.
  • block_banners: Blocks cookie, GDPR, and similar banners and popups. The default is true.
  • block_ads: Blocks advertisements. The default is true.
  • image_quality: Sets the quality of lossy formats such as jpg and webp from 1 to 100. The default is 80.
  • full_page: Captures the entire page instead of only the visible viewport. The default is false.
  • full_page_max_height: Limits the height of a full-page screenshot in pixels. It requires full_page=true.

The response contains the file as an embedded resource with its MIME type, for example image/jpeg or application/pdf, and a text block with the file name, size, and temporary URL:

{
"name": "example.com-2026-11-03-120000.jpg",
"uri": "screenshotone://screenshots/example.com-2026-11-03-120000.jpg",
"mime_type": "image/jpeg",
"size": 48213,
"url": "https://files.screenshotonecache.com/example-screenshot.jpg"
}

Files larger than 5 MB are not embedded. The tool then returns an error that suggests a smaller option, such as jpg with a lower image_quality, pdf, a full_page_max_height, or a viewport-only screenshot, and includes the temporary URL of the file.

Renders HTML that the agent writes or that you provide, such as a social card, a chart, a report, or a page template, and returns the screenshot as an image the agent can see and analyze, together with its file name and size. Images, fonts, and stylesheets that the HTML references by URL are loaded. Use it only when you have HTML and no publicly reachable URL for it, for example a page on localhost or behind a login. For a public page, use render-website-screenshot or render-website-screenshot-as-file instead. Use absolute URLs for images, fonts, and stylesheets in the HTML, because relative links can’t load.

The tool accepts the following options:

  • html: The HTML document or fragment to render, up to 1,000,000 characters. The agent passes it exactly as given.
  • viewport_width: The viewport width in pixels, from 320 to 3840. The default is 1280; use the width the HTML is designed for, for example 1200 for a social card.
  • full_page: Captures the full height of the HTML instead of only the first viewport. The default is true.
  • image_quality: Sets the JPEG quality from 1 to 100. The default is 80.

Agents write HTML well, but most can’t run a browser to see how it looks. With this tool, the agent generates the HTML and gets the image back in one call. For example:

Write HTML for a 1200×630 social card for a blog post titled "Launch week",
then render it with ScreenshotOne's render-html-screenshot-as-file tool
using viewport_width=1200 and show me the image.

Other uses include turning an HTML chart or table into an image for a report, previewing a page template, or checking how HTML that you already have renders.

The response contains the screenshot itself as an inline JPEG image (type: "image"), so the agent sees it without downloading anything, and a text block with its details:

{
"name": "html-2026-11-10-120000.jpg",
"mime_type": "image/jpeg",
"size": 118928
}

The response doesn’t include a temporary URL. Images larger than 5 MB are not returned; the tool then returns an error that suggests a lower image_quality or full_page=false.

The agent writes the HTML into the tool call, so large HTML takes longer and uses more tokens. For HTML generated by your own code, call the API’s html option directly with a JSON POST request.

Renders a public website and returns its cleaned Markdown directly as MCP text. Use this tool when the agent needs to read, summarize, or extract information from a page without receiving a screenshot.

The tool accepts only one option:

  • url: The HTTP or HTTPS URL to extract.

It is a focused shortcut for the ScreenshotOne API’s format=markdown response. No other screenshot or Markdown options are exposed.

Returns the ScreenshotOne API quota and concurrency usage for the connected organization. This is useful before an agent starts a larger batch of captures.

See the ScreenshotOne MCP page for supported clients and example workflows. To choose between ScreenshotOne and servers that run a browser on your computer, see the comparisons of screenshot MCP servers and Markdown MCP servers.

If you prefer to run the same screenshot, HTML, and Markdown tools as a local command-line MCP server, see the ScreenshotOne MCP server on GitHub.

Open the ScreenshotOne Dashboard, go to Integrations, and select Connect MCP clients.

The MCP connections page lists the clients connected to your organization. You can review each connection, rotate its API key, or revoke its access.