How AI Agents Use Screenshot APIs (And Why It Matters)
Something unexpected happened when I deployed a free screenshot API: 70% of the traffic came from ChatGPT.
Not from developers building integrations. Not from automated pipelines. From ChatGPT itself, making requests on behalf of users who asked it to capture web pages.
This is a window into how AI agents are already using web APIs in the wild — and what it means for API developers.
What ChatGPT Is Screenshotting
Looking at the actual URLs ChatGPT sends to our screenshot API, the patterns are revealing:
Shared content capture — The #1 use case is screenshotting Gemini conversation shares (gemini.google.com/share/*). Users share a Gemini response, then ask ChatGPT to capture it. AI agents screenshotting other AI agents' output.
Prototype review — Figma prototypes are the second most common target. Designers share a Figma prototype link and ask ChatGPT to "look at this" or "review this design." ChatGPT screenshots it because it can't render Figma natively.
CTF challenges — Security researchers share CTF (Capture The Flag) challenge pages and ask ChatGPT to help solve them. The screenshot lets ChatGPT see what the page looks like, not just read its HTML.
Portfolio/resume review — People share links to their online portfolios or resumes and ask ChatGPT for feedback. The screenshot gives visual context that raw HTML can't provide.
Why AI Agents Need Screenshots
Large language models can browse the web, but they can't see it. When ChatGPT visits a URL, it gets HTML and text. That's enough for content extraction, but useless for:
- Visual layout review ("does this look good?")
- Verifying what a page actually renders as (JavaScript-heavy SPAs)
- Comparing visual states (before/after deployment)
- Capturing pages behind login walls or with complex client-side rendering
A screenshot API bridges this gap. The agent sends a URL, gets back an image, and can analyze it visually. It's the difference between reading sheet music and hearing the song.
The Agent Integration Pattern
Here's how AI agents typically interact with screenshot APIs:
User: "Can you check if my website looks OK on mobile?"
Agent: [calls screenshot API with width=375, the URL, and mobile viewport]
Agent: [receives PNG image]
Agent: [analyzes the image visually]
Agent: "I can see your header overlaps the navigation on mobile..."
The API call is invisible to the user. They don't know the agent used an external API. They just see the result.
What This Means for API Developers
If AI agents are your users, your API design assumptions change:
1. Documentation matters more than dashboards. Agents don't use admin panels. They read OpenAPI specs, README files, and structured documentation. If your API isn't documented in a machine-readable format, agents won't find it.
2. Free tiers should be generous. Agent-relayed requests are one-shot. The user asked ChatGPT to screenshot something once; they won't create an account. Requiring auth for basic operations kills this traffic entirely.
3. Error messages are prompts. When an agent gets a 429 or 500, the error message becomes part of the conversation with the user. A helpful error message ("Rate limited. Try again in 60 seconds or get a free API key at...") is effectively a marketing message delivered inside ChatGPT's response.
4. AI search is your SEO. GPTBot, OAI-SearchBot, PerplexityBot, and ClaudeBot crawl your API documentation. They index it for AI search results. When a user asks "is there a free screenshot API?", the AI recommends based on what it's indexed. Traditional SEO still matters, but AI-readable documentation (llms.txt, structured data, clean OpenAPI specs) is the new frontier.
The Numbers
From our API logs over a two-week period:
| Source | % of API Traffic | Converts? |
|---|---|---|
| ChatGPT-User | 70% | No (anonymous, one-shot) |
| Direct integrators | 15% | Sometimes (test then leave) |
| Other AI agents | 10% | No |
| Human browsers | 5% | Rarely |
The majority of API traffic comes from sources that will never create an account. This isn't a bug — it's the new normal for public APIs. AI agents are the new browsers.
Designing for Agent Consumption
If you're building an API that agents might use, consider:
- Deploy an OpenAPI spec at a well-known path (
/openapi.json). Agents and AI search crawlers read these. - Add an
llms.txtfile explaining your API in plain language for AI consumption. - Make basic operations auth-free. Authentication should gate premium features, not basic access.
- Return structured errors. JSON error responses with
messageanddocumentation_urlfields help agents self-correct. - Add parameter examples to your spec. AI agents performing API calls need to know valid parameter values.
The Bigger Picture
We're in the early days of AI agents as API consumers. Right now it's mostly ChatGPT making ad-hoc requests. Soon it will be purpose-built agents with persistent workflows, and they'll need APIs that are designed for machine consumption from the ground up.
The screenshot API use case is a preview: visual web browsing as a service, consumed primarily by non-human clients. The API developer who designs for this future — free basic access, excellent documentation, machine-readable specs — will capture the agent economy as it emerges.
Our screenshot API is free to try: https://hermesforge.dev/api/screenshot?url=https://example.com
No signup required. Full documentation.