screeenly now runs an MCP server. Add it to your agent once, and it can take a screenshot of a page, turn a page or some HTML into a PDF, or read the HTML of a JavaScript app after it rendered.
The server is at https://3.screeenly.com/mcp and uses the same API tokens as the REST API. Create a token in your dashboard, then add the server to your client.
Claude Code:
claude mcp add --transport http screeenly https://3.screeenly.com/mcp \
--header "Authorization: Bearer YOUR_API_TOKEN"
Cursor, in .cursor/mcp.json:
{
"mcpServers": {
"screeenly": {
"url": "https://3.screeenly.com/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_TOKEN"
}
}
}
}
Other clients work the same way: add a remote HTTP server with that URL and an Authorization header. The MCP page in your dashboard has these snippets with copy buttons.
| Tool | What it does |
|---|---|
capture_screenshot |
Takes a screenshot (JPG, PNG, WebP) or creates a PDF of a URL or of HTML. Accepts most options of the screenshot API, such as window_width, full_page and selector. |
get_rendered_html |
Loads a URL or HTML in Chrome, runs its JavaScript and returns the resulting HTML. |
get_usage |
Returns the plan, the requests used this month, the monthly limit and the credit balance. |
list_recent_shots |
Lists the most recent captures of the account, newest first. |
Then ask in plain words, for example: "Take a screenshot of our pricing page at 390 pixels wide and attach it to the pull request."
Captures through MCP count toward your monthly usage like API requests, and cached results are free. When you reach your limit, the tools return an error that explains why, so the agent tells you instead of retrying.
Download URLs are valid for 24 hours.
Create a separate token for each agent or tool. The request log shows which captures came from MCP, and you can revoke one token without breaking the others.
If an agent only needs to check the usage or list earlier captures, create a token with only the shot:read ability. It can't create new captures.
Open the playground, set the options you want and copy the request as an agent prompt. It lists every option you set, so the agent sends the same request.
The MCP server is part of every plan, including the free plan. Questions? Email support@screeenly.com.
]]>Starting today, screeenly remembers the result. When you send a request that matches an earlier successful request of your account, you get the stored file back. It's faster, and it doesn't count toward your usage or use a credit.
Two requests match when they go to the same endpoint with the same URL (or the same HTML) and the same options. Options you leave out and options set to their default value are treated the same. Cookies, HTTP headers and basic auth credentials are part of the match, so a request with a different session cookie renders again.
The scheme and the host of the URL are compared without case, and the #fragment is ignored. The path and the query string have to match exactly.
Results are only reused within your own account. Another account never gets your files.
Screenshots, PDFs and rendered HTML used to expire after 60 minutes. They are now kept for 24 hours, and a matching request returns the stored result during that time. The expires_at field in the response tells you when the file goes away.
Playground results still expire after 60 minutes and are never reused.
| New render | From the cache | |
|---|---|---|
| Status code | 201 |
200 |
X-Cache header |
MISS |
HIT |
| Counts toward usage | Yes | No |
If your code checks for 201 exactly, change it to accept any 2xx status.
On a paid plan or with credits, you control the cache per request:
cache=false skips the lookup and always renders a new file. Use it if you capture the same page to see whether it changed.cache_ttl sets how long the result is kept and reused, from 60 to 86,400 seconds. Use a short value if you don't want the file stored for a full day.curl --request POST \
--url https://3.screeenly.com/api/v1/shots \
--header "Authorization: Bearer $TOKEN" \
--data url=https://example.com \
--data cache=false
Accounts on the free plan always use the cache with the 24 hour default.
There's a second way to avoid paying for the same work twice. Send an X-Request-ID header with a value of your choice. If the connection drops and you send the same request with the same ID again, screeenly returns the first response and adds X-Request-Replayed: true. The retry isn't charged.
422.409. Wait for it and retry.If you don't send the header, screeenly creates an ID for you and returns it in the X-Request-ID response header. Include it when you email support about a request.
Questions? Email support@screeenly.com.
]]>If your trial ran out, your API tokens work again. You can make 100 requests a month without doing anything.
If you're on a plan, the 100 free requests are added on top of your plan. Small now includes 2,100 requests a month, Base 10,100, and so on.
If you're new, you can sign up and start using the API right away. There's no trial that ends after 14 days.
Accounts without a plan and without credits have lower limits:
device_scale_factor of 1delay up to 2,000 ms and timeout up to 15 secondsA request above one of these limits fails with a message that says which limit it hit. As soon as you have a plan or any credits, the limits are the same as on every paid plan.
You can now buy credits next to your plan, or without one:
| Credits | Price | Per request |
|---|---|---|
| 1,000 | $9 | $0.009 |
| 2,000 | $16 | $0.008 |
| 5,000 | $35 | $0.007 |
| 10,000 | $60 | $0.006 |
| 20,000 | $100 | $0.005 |
| 50,000 | $200 | $0.004 |
One credit pays for one request, whether it's a screenshot, a PDF or rendered HTML. Credits are only used once your monthly requests run out, and they don't expire. Prices are in USD and exclude tax. If you need more than 50,000 credits at once, email us.
You buy credits on the billing page. Every change to your balance shows up there: purchases, credits we add for you, and each request that was paid with a credit.
If you use the API every month, a plan is still the cheaper option. Small costs $15 for 2,100 requests a month.
A request that fails validation (for example, a missing url or an invalid window_width) no longer counts toward your monthly usage and doesn't use a credit. Requests that fail while rendering or time out still count, because the browser already ran.
Every API response now includes two headers, so you can watch your usage from your code:
X-Usage-Remaining: requests left this monthX-Credits-Remaining: your credit balanceWhen your monthly requests and your credits are both used up, the API returns 403 until the next month starts, the same as before.
Questions? Email support@screeenly.com.
]]>Every feature now has its own page: screenshots, PDFs, your own HTML, rendered HTML and the MCP server. Each page lists the options, code you can copy and the questions we get most often.
We also added comparisons with other screenshot APIs. They include the cases where another service fits better.
The dashboard was rebuilt from scratch. It shows your free requests, your plan allowance and your credit balance in one place, and the request log shows whether a request came from the API, the MCP server or the playground.
Some pages moved:
/app/billing/app/account/app/request-logNew accounts get a checklist that walks them from the first API token to the first request. The playground can copy any request as curl, as PHP, or as a prompt you can paste into your agent.
Every account gets 100 free requests a month, and you can buy credits for the months you need more. We wrote about it in screeenly now has a free plan.
Two changes can affect code that already uses the API:
200 with X-Cache: HIT instead of a new render with 201. Send cache=false to render again.The details, and the other API changes, are in Identical requests are now free and API changes in November 2026.
screeenly now runs an MCP server, so Claude, Cursor and other MCP clients can take screenshots and create PDFs with your API token. See Let your agent take screenshots.
screeenly started as an open source project in July 2014 and has handled more than 21 million requests since. The open startup page shows revenue, users and requests per month.
If something looks broken or works differently than before, email support@screeenly.com.
]]>Two new options stop the browser from loading resources you don't need:
block_urls: skip every request whose URL contains one of these strings.block_domains: skip every request to these domains.curl --request POST \
--url https://3.screeenly.com/api/v1/shots \
--header "Authorization: Bearer $TOKEN" \
--data url=https://example.com \
--data "block_domains[]=googletagmanager.com" \
--data "block_urls[]=/ads/"
Both accept up to 50 entries. They work for screenshots, PDFs and rendered HTML, and in the playground.
Some options could be set to values that Chrome can't render, or that made a request run for minutes. They now have limits. A request above a limit fails validation with a 422, which doesn't count toward your usage.
| Field | Maximum |
|---|---|
| Screenshot size | 16,384 pixels per side and 40 megapixels in total. The window or clip size is multiplied by device_scale_factor first. |
clip_width, clip_height |
Same as the screenshot size. They had no limit before. |
paper_width, paper_height |
5,000 mm (was 100,000 mm) |
html |
2,000,000 characters |
header_html, footer_html |
100,000 characters each |
http_headers, cookies, block_urls, block_domains |
50 entries each |
| Header values / cookie values | 8 KB / 4 KB |
A 1440 × 900 window at device_scale_factor=3 is 4320 × 2700 pixels, or 11.7 megapixels, and still works. A 10,000 × 10,000 window at 3× doesn't, and never produced a usable image anyway.
Every response now has an X-Request-ID header, also when the request failed. Send your own ID in the same header to retry a request safely: a repeat with the same ID returns the first response and isn't charged again. The caching post explains how it works.
Include the request ID when you email support about a request. We can find it in our logs right away.
API tokens now have abilities, and the API checks them:
shot:create creates screenshots, PDFs and rendered HTML. The API needs it.shot:read lists your captures and reads your usage over the MCP server.shot:create includes shot:read. Every existing token has shot:create and keeps working.
A request that fails validation, for example with a missing url or a window_width that's too large, no longer counts toward your usage. Requests that fail while rendering or time out still count, because the browser already ran.
| Header | Value |
|---|---|
X-Request-ID |
The ID of the request |
X-Cache |
HIT when the result came from the cache, MISS otherwise |
X-Request-Replayed |
true when the response is a replay of an earlier request with the same ID |
X-Usage-Remaining |
Requests left this month |
X-Credits-Remaining |
Your credit balance |
X-Usage-Resets, meta.usage_limit.resets and the dashboard was one month too late. It's correct now.The API reference lists every option with its limits. Questions? Email support@screeenly.com.
]]>