# Best screenshot API: 3 APIs an agent can call

Screenshot API comparison: three website screenshot APIs an agent can call, with full-page and viewport options, output format and live price per call.

## Summary

A screenshot API takes a URL and returns an image of the page, so an agent can see what a person would see. Agents use one to feed a vision model, to check that a deploy did not break a layout, or to keep a dated copy of a page. Running your own headless browser for that means installing Chromium, handling cookie banners and waiting for scripts to finish.

This post ranks the three website screenshot APIs in the looot catalog that an agent can call per page. It covers what each returns, which options each one takes (full page, viewport size, a wait before capture), live prices, a guide for choosing, a prompt and a FAQ. All three also scrape a page to markdown, so we compare that too.

## Best screenshot API: the short answer

Each provider wins a different job. Pick by what you need back, not by the brand.

- **Context.dev**, best for full-page captures of sites with cookie popups: it takes a domain or a direct URL and can dismiss the banner first.
- **ScrapeGraphAI**, best for setting the exact image size: width, height and quality are parameters, and it returns an image URL.
- **Steel**, best when the page needs time to render: a delay of up to 10 seconds waits for scripts before the capture.

| Provider | What the screenshot endpoint returns | Options in the catalog description | Other web capabilities in the catalog | Billing unit |
|---|---|---|---|---|
| Context.dev | The screenshot with height and domain | fullScreenshot, viewport, waitForMs, colorScheme, handleCookiePopup | Markdown scrape, HTML scrape, image scrape, crawl, extract, search, site map | Per call |
| ScrapeGraphAI | An image URL | fullPage, width 320 to 3840, height 200 to 2160, quality 1 to 100 | Markdown scrape, AI extract to JSON, crawl, search | Per call |
| Steel | A screenshot of the page | delay up to 10,000 ms, default 2,000 | Markdown or HTML scrape, page to PDF | Per call |

Prices are read from the catalog when the page loads, one row per provider.

Screenshot price per call. Prices read on 2026-11-10 from the live looot catalog. They change when a provider changes its price.

| Option | Cheapest provider | Price per call |
|---|---|---|
| Context.dev | Context.dev | $0.0025 per call |
| ScrapeGraphAI | ScrapeGraphAI | $0.0040 per call |
| Steel | Steel API | $0.0050 per call |

## Key takeaways

- Only ScrapeGraphAI says in its description that it returns an image URL. The other two describe "the screenshot" without saying whether it comes as a link or as encoded data, so test one call before you wire the output into a vision model.
- Only Context.dev lists a cookie popup option and a color scheme option. That matters for archiving, where a banner over the content ruins the copy.
- Steel lists no full-page or viewport option. It captures what its browser shows after the delay.

## How we ranked these screenshot APIs

We read the public looot catalog on 2026-11-04 and kept every provider with an endpoint tagged web_screenshot that the blog can price. We ordered them by the price per call of that endpoint, cheapest first. All three bill per call, one page per call, so no per-result price had to be converted. If two had tied on price, breadth of other web capabilities in the catalog would have broken the tie.

We did not run these endpoints for this post. The catalog marks all three as unverified and publishes no success rate or speed figure for them, so we rank on neither. We do not rank image quality either. The blog's provider snapshot is dated 2026-10-12.

## 1. Context.dev, best for full-page captures with cookie banners

The endpoint context-dev-web-screenshot captures a screenshot of a website. You send either a domain or a directUrl. Optional fields refine it: fullScreenshot for the whole page, viewport for the window size, waitForMs for a wait before capture, colorScheme for the color scheme, and handleCookiePopup. The response holds the screenshot plus the page height and domain. Context.dev has more web capabilities in the catalog than the other two, from markdown and HTML scrapes to a crawl and a site map.

**Best for**

- Archiving a homepage each week, with the cookie banner handled so the content is visible.
- Visual checks of the same site under a different color scheme, through colorScheme.

**Strengths**

- One call can take just a domain, so the agent does not have to guess the right URL.
- Full page and viewport are both options, so one provider covers above-the-fold checks and whole-page archives.

**Limits**

- The description does not say whether the screenshot comes back as a URL or as encoded data. Read one response first.
- The call needs a domain or a directUrl. Send one of them.

**Does not fit** a job that needs exact pixel dimensions set per call. ScrapeGraphAI lists width and height ranges, Context.dev lists a viewport option without ranges.

## 2. ScrapeGraphAI, best for set image sizes and a link back

The endpoint scrapegraphai-screenshot takes a page and returns the image URL. fullPage captures the whole scrollable page. Width runs from 320 to 3840 pixels, height from 200 to 2160, and quality from 1 to 100. A URL is easy to pass to a vision model or store in a sheet. ScrapeGraphAI's other catalog endpoints include a markdown scrape, an AI extract that returns JSON for a prompt, a crawl and a search that reads each result page.

**Best for**

- Mobile and desktop captures of the same page, by setting width to 390 for one call and 1440 for the next.
- Feeding a vision model a link instead of a large payload.

**Strengths**

- The size and quality ranges are in the description, so the agent can set them without trial and error.
- The output format is stated: an image URL.

**Limits**

- The description lists no wait option. A page that renders late may be captured before it finishes.
- No cookie popup option is described.

**Does not fit** single-page apps that load content seconds after the first paint.

## 3. Steel, best for pages that need time to render

The endpoint steel-screenshot takes a url and a delay. The delay waits for the page before the capture, up to 10,000 ms, with a default of 2,000. The catalog warns that a slow page plus a long delay can time out, so keep the delay short. The price is flat per call. Steel has the fewest capabilities of the three: this screenshot, a scrape that returns markdown or HTML (and can add a screenshot and a PDF in the same call), and a page to PDF.

**Best for**

- Dashboards and charts that draw after a few seconds of JavaScript.
- Saving a page as both a PDF and an image for a record.

**Strengths**

- The delay is explicit and bounded, so the agent knows how long it will wait.
- The scrape endpoint can return content, a screenshot and a PDF in one call.

**Limits**

- No full-page, viewport or size option is described for the screenshot endpoint.
- A long delay on a slow page can time out.

**Does not fit** a job that needs the whole scrollable page in one image.

## How to choose

### What do you need back?

For a URL you can hand to a vision model, ScrapeGraphAI states it returns one. For the whole page with the cookie banner gone, use Context.dev. For a page that only looks right after its scripts run, Steel's delay is the clearest control. To try a single capture before you wire anything, the free [website screenshot tool](https://looot.ai/free-tools/website-screenshot) returns a PNG of one page in a desktop viewport.

### Do you also need the text of the page?

All three scrape a page to markdown, so one provider can give the agent both the image and the words. This is the case for an agent that reads a pricing page and checks the layout in the same run. For a wider list of scrapers, see the [best web scraping API](https://looot.ai/best/web-scraping-api) ranking, and [web crawler vs web scraper](https://looot.ai/blog/web-crawler-vs-web-scraper) for when you need a crawl instead.

Markdown scrape price per call, same providers. Prices read on 2026-11-10 from the live looot catalog. They change when a provider changes its price.

| Option | Cheapest provider | Price per call |
|---|---|---|
| Context.dev | Context.dev | $0.0025 per call |
| ScrapeGraphAI | ScrapeGraphAI | $0.0020 per call |
| Steel | Steel API | $0.0050 per call |

### How many pages do you capture?

Every endpoint here bills per call, one page per call. A run over 500 URLs is 500 calls, so the total is the per-call price times the rows. Put the row count and a budget in your prompt so the agent stops at the limit.

### Does it need to run on a timer?

Capturing a page every morning for an archive needs scheduled runs, not available yet. Run the prompt by hand, or from your own cron job that starts the agent.

| Your need | Pick | Why |
|---|---|---|
| Whole page, banner dismissed | Context.dev | fullScreenshot and handleCookiePopup |
| Exact width and height | ScrapeGraphAI | Width 320 to 3840, height 200 to 2160 |
| An image link for a vision model | ScrapeGraphAI | Returns the image URL |
| A page that renders late | Steel | Delay up to 10,000 ms |
| Image, text and PDF in one call | Steel | The scrape endpoint adds screenshot and pdf |

## How to run this with an agent

1. Connect your agent to looot once with the setup line in the prompt below.
2. Ask it to search the catalog for "take a screenshot of a web page". It lists each endpoint with its inputs and price.
3. Give it three URLs and name two providers to compare.
4. Look at the images side by side. Check for cut-off content, cookie banners and blank areas that had not loaded.
5. Run the one that worked on the full list, with a budget cap.

Each provider's setup page shows its endpoints: [Context.dev on looot](https://looot.ai/mcp/context-dev) and [Steel on looot](https://looot.ai/mcp/steel). The full list is in the [public catalog](https://looot.ai/public-catalog).

## What this post does not cover

It covers one page per call through an API. It does not cover visual diffing, PDF reports or browser sessions where the agent clicks through a flow. It makes no claim about image quality or capture speed, because the catalog publishes neither for these endpoints. Screenshot providers in the live catalog that are not in the blog's provider snapshot are left out until the snapshot is refreshed.

Last checked 2026-11-04 against the public catalog at https://api.looot.ai/v1/public-catalog. Author: the looot team. The blog's provider snapshot is dated 2026-10-12.

## Questions

### What is a screenshot API?

A screenshot API loads a web page in a remote browser and returns an image of it. You send a URL, and options such as full page or viewport size, and get back an image or a link to one. Agents use it when text alone misses the point, such as a broken layout.

### Which screenshot API is the cheapest?

The live price table above answers that, because prices change. All three bill per call, so the per-call row is the whole comparison. Check which options you need before you pick on price alone.

### Is there a free screenshot API?

This post covers priced endpoints, and none of the three is free. For a one-off capture, the free website screenshot tool on looot returns a PNG without an account.

### Can a website screenshot API capture the full page?

Two of the three describe it. Context.dev has fullScreenshot and ScrapeGraphAI has fullPage. Steel's description lists no full-page option.

### How does an agent call a screenshot API?

With looot, the agent searches the catalog, reads an endpoint's inputs and price, then runs it with your token. The provider's response comes back as named fields, and you pay the per-call price shown before the call.

### Should I run my own headless browser instead?

Run your own if you already maintain browser infrastructure and capture many pages a minute. Otherwise an API saves you installing a browser, keeping it updated and handling banners and timeouts. You can start with an API and move later, because the input is just a URL.

### Which one handles 10,000 screenshots a day?

The catalog makes no promise on volume or rate limits for these endpoints. Each bills per call, so cost scales linearly with pages. Test a few hundred calls and watch for timeouts before you commit, and keep Steel's delay short.

### Why does this post show no success rates or speed numbers?

The catalog publishes no measured success rate or speed for these endpoints, and all three are marked unverified. We show none rather than guess. Run your own URLs through two of them before a large job.

## For agents

### Screenshot a list of pages

```text
Use looot to take screenshots of the pages in my list.
1. Set up https://looot.ai/skill.md.
2. Search the catalog for "take a screenshot of a web page" and list each endpoint with its price per call and its options (full page, viewport, wait).
3. Capture the first three URLs from my list with the two cheapest endpoints and show me the images side by side.
4. Tell me before each call what it will cost, and stop if the total passes my budget.
```