Frequently asked questions

Generally 15 to 30 seconds from the website. API requests can take up to 45 seconds as they go through a processing queue. Delays vary with current load. Accounts with a screenshot reserve are processed on a priority queue and typically see shorter wait times.

Right after submission, the screenshot is being processed (15-30 s).

In APIv2, the response contains {"status":"queued"} or "processing"; poll GET /capture/{token} every 2-3 s until "done".

In the legacy API, the URL returns a placeholder image while processing; reload after 30 s.

If the screenshot remains blank after several minutes, the target site may have refused the connection or shown a blocking screen. Try the No JavaScript option.

Not necessarily. The target server did not respond within the allowed timeout.

In APIv2, the returned status will be "failed" with an explanatory error field. In the legacy API, the image shows a placeholder.

Check that the site is online, DNS is correct, and resubmit. Some sites actively block bots: try the No JavaScript option or increase the wait parameter (up to 30 s with Shotbot Pro) for slow SPAs.

Yes. The rendering engine is a modern headless browser (Chromium) that executes JavaScript, loads resources, and waits for initial page load to complete before capturing. For sites with blocking pop-ups or disclaimers, check "No JavaScript" in the form.

Yes, via APIv2 with the http_auth parameter. Pass {"user": "login", "pass": "password"} in your request: Shotbot performs HTTP Basic authentication before capturing. Credentials are deleted from the database as soon as the screenshot is complete, or automatically after 2 hours if the screenshot remains pending. See the API documentation.

Yes, Shotbot handles HTTPS/SSL sites without any special configuration. Just submit the full URL including https://.

If a screenshot is already queued or being processed for that URL, Shotbot does not create a duplicate. If the screenshot already exists and was recently generated, the response is immediate. A new screenshot is triggered if you explicitly request an update.

Yes, as long as your account is active. Screenshots from accounts inactive for more than a year (no login, no payment, and whose screenshots are no longer viewed) may be deleted during maintenance operations. Screenshots from anonymous users may be purged after a short period of inactivity.

Shotbot screenshots are immutable, timestamped snapshots: each screenshot is archived under a unique identifier, never modified or overwritten. A new screenshot of the same URL generates a distinct identifier, allowing you to document site changes over time. These characteristics make them useful as visual evidence (disputes, legal notices, compliance). For full legal evidentiary value (certified bailiff report, certified timestamp), we recommend supplementing with an accredited trusted third-party service. See the dedicated legal archiving page.

Yes. Each screenshot is recorded with its exact creation date and time. The generation date is visible in your capture log (My account → Log). The screenshot's unique identifier (32-hex token for APIv2) allows you to retrieve and reference it in your history.

Shotbot enforces a size limit on the HTML document downloaded by the browser before attempting a screenshot. This protection prevents an extremely large page from consuming all available server memory and degrading other captures.

Limits by account type:

• Batch / Free: 10 MB


• Pro (single capture): 20 MB


• Anonymous try-it: 5 MB

For legitimately large pages, contact us. The limit can be raised on Dedicated accounts.

No. Each screenshot is immutable: once generated, it cannot be modified or replaced. Resubmitting the same URL creates a new screenshot with a new identifier. Previous screenshots remain accessible and unchanged. This immutability is a guarantee for legal archiving and traceability use cases.

Contact us with the address of the site in question: we'll investigate the behavior and fine-tune detection.

Depends on the mode.

APIv2 (recommended): 10 viewports from 360 to 1920 px (360, 375, 390, 414, 430, 768, 1024, 1280, 1440, 1920). Shotbot Pro subscribers can also request any custom width from 280 to 3840 px via the API, handy for CSS / responsive testing. Output size is independently configurable (120 to 1920 px) and the ratio is adjustable (16:9, 9:16, 1:1, etc.). Full page available. HiDPI ×2 available.

Legacy API: viewport 768, 1024, 1280, or 1600 px, scaled to 6 fixed sizes (320×240, 240×180, 160×120, 120×90, 92×69, 80×60).

Full details in the API documentation.

JPEG (default), PNG, WebP, and AVIF.

In APIv2, the format is passed in JSON via the format field (jpg, png, webp, avif). In the legacy API, via the /format/webp/ parameter in the URL.

AVIF offers the best compression at equivalent quality, ideal for CDN.

Shotbot Pro subscribers can set any viewport width between 280 and 3840 px via the API (the viewport_width parameter), ideal for checking how a site renders at a specific CSS breakpoint.

This custom width is API-only: the website forms keep the preset viewport list. Non-Pro accounts stay limited to 390, 768, and 1280 px.

A value outside the range returns a 400 invalid_viewport_width error.

With HiDPI enabled, the browser simulates a Retina screen with a ×2 scale factor: images output at twice the requested resolution. Useful for high-density displays (modern mobiles, 4K screens) or to retain margin for client-side resizing.

Without this option, Shotbot only captures the visible part of the site (the viewport). With "Full page", the browser scrolls to the bottom and captures the entire page, even if it is very long.

Shotbot injects prefers-color-scheme: dark into the browser. If the target site supports dark mode via CSS, the screenshot will be taken in its dark version. Without CSS support on the site side, the option has no effect.

Disables JavaScript execution during rendering. Useful for sites that show blocking pop-ups, cookie banners, or terms-of-service overlays on load: the screenshot is taken before those elements appear.

APIv2 offers 11 predefined ratios:

Landscape: 16:9 (default), 4:3, 16:10, 3:2, 2:1.

Portrait: 9:16 (mobile), 3:4, 10:16, 2:3, 1:2.

Square: 1:1.

For a custom height, pass crop_height in pixels (ratio becomes custom). Ratios are ignored in fullpage mode which captures the full page height.

The legacy API does not expose the ratio parameter (fixed 4:3 format only).

The wait parameter (in seconds, default 5) tells Shotbot how long to wait after initial page load is considered complete, before taking the screenshot. Allowed range: 0-5 s (free account), 0-30 s (Pro).

Useful for modern SPAs and pages that load content progressively. A value of 5-15 s covers most cases.

For sites with blocking pop-ups (cookies, ToS), prefer the nojs option instead, which disables JavaScript entirely.

Each screenshot creation or update consumes 1 unit. Displaying an existing screenshot is free and unlimited. The quota resets on the 1st of each month at 3 AM (Paris time). Credits in reserve are only consumed once the monthly quota is exhausted.

New requests are placed in the queue. They will be processed when the quota resets on the 1st of the following month, or immediately if you top up with additional credits. Note: accounts with an active credit reserve get a priority queue, regardless of the monthly quota.

No. Purchased credits have no expiry date. They remain available as long as your account is active.

200 screenshots per month, reset on the 1st of each month. No credit card required to sign up.

Yes, for occasional use: 10 screenshots per day without an account. Format, resolution, HiDPI, dark mode, and API access require a free account.

Go to the Sign up page. All you need is an email address and a password. Access is immediate after email verification.

From your preferences, you'll find a permanent account deletion option (self-service, no need to contact us).

Deletion immediately erases your account, sessions, preferences, and pending screenshots. Completed screenshots may remain accessible for up to 1 year after your last activity, then are deleted automatically. Payment data is retained for 10 years (legal accounting obligation, French Commercial Code, Art. L123-22).

Any unused credits are forfeited upon deletion (non-refundable). To exercise your GDPR rights with written acknowledgment, use the contact form.

Yes, from the Scheduled captures page. You can schedule URLs to be automatically re-captured every 6h, 12h, 24h, 48h, or 7 days. The limit depends on your credit balance: 5 URLs on a free account, 30 after a first top-up, 100 with 1,000+ credits, 500 with 10,000+ credits. Each execution consumes 1 screenshot from your monthly quota. Scheduled captures are automatically paused if your account remains inactive for 6 months (you'll receive an email). Schedules paused for over a year are permanently deleted - you can reactivate them before that deadline from the Scheduled captures page.

Email delivery (Shotbot Pro): Shotbot Pro subscribers can enable automatic email delivery on each execution. The screenshot is embedded directly in the message (image visible without clicking) along with schedule details: URL, frequency, options, run number. Useful for competitor monitoring or automated visual archiving. Each email also compares the capture to the previous one and shows an "Updated since last run" or "No change since last run" badge, so you can spot changes without manual comparison.

The built-in Shotbot scheduler doesn't trigger webhooks directly. To receive the image automatically on each run, use the API from your own cron job: call POST api.shotbot.net/capture with a callback_url parameter : Shotbot will POST the image multipart to your endpoint as soon as the screenshot is ready.

You control the exact timing, frequency, and processing logic on your side. The Scheduled captures page is ideal for code-free visual monitoring; the API with callback is the right fit when your application needs to ingest the image automatically. See code examples for callback mode.

The capture is skipped (not added to the queue) and the next attempt is rescheduled 1 hour later. If you have enabled quota alerts in your preferences, an email notification is sent.

Once your quota resets (on the 1st of the month) or you top up with credits, schedules resume normally at their next interval.

No. The interval is calculated from the time of the previous execution, not from a fixed time of day. If you schedule a URL at 2:32 PM with a 24-hour interval, the next capture will run around 2:32 PM the following day.

If a run is skipped (quota exhausted), the next attempt is pushed back by 1 hour, shifting the rhythm by that amount. If you need a precise, reproducible execution time, use your own cron job and call the API directly.

The schedule stays active and keeps running normally. Pro-only options (block ads & trackers, force lazy-load, cookie banner handling) are silently ignored until Shotbot Pro is renewed. All other options (format, viewport, dark mode, etc.) continue to apply normally. The schedule is neither paused nor deleted automatically.

Create a free account or sign in, then go to the API Key page. Your key (12 alphanumeric characters) is available immediately in your account dashboard.

Shotbot exposes two APIs:

APIv2 (recommended, JSON REST):
POST https://api.shotbot.net/capture - submit a screenshot (hosted mode).
GET https://api.shotbot.net/capture/{token} - query the status.
POST https://api.shotbot.net/capture/callback - submit with callback (white-label).
POST https://api.shotbot.net/capture/batch - up to 500 URLs in one request.

Legacy API (URL-based):
https://add.shotbot.net/k={key}/url={url}, options in path (/nojs/1/, /format/webp/, /w/1280/, /fullpage/1/, /hidpi/1/, /darkmode/1/).

Full details in the API documentation.

APIv2 returns JSON.

On submission (POST /capture): {token, status, eta_seconds} with status = queued, processing, done, or waitlisted. Errors: {error: "invalid_key|invalid_url|missing_url|invalid_json", ...} with appropriate 4xx HTTP code.

On polling (GET /capture/{token}): {status, image, preview, format, url} when status=done.

Legacy API returns plain text: OK (created), OK waitlist (queued), ERR key (invalid key), ERR url (invalid URL), ERR args (incorrect parameters).

Three cases depending on the mode used.

APIv2 hosted (POST /capture): poll GET https://api.shotbot.net/capture/{token}; when status is done, the response contains image (direct URL) and preview (640 px WebP preview). URL format: https://static.shotbot.net/{t1}/{t2}/{token}.{format} (t1 = 1st token character, t2 = first 2). Preview: https://cache.shotbot.net/t/{token}/preview.

APIv2 callback (POST /capture/callback): Shotbot pushes the binary image directly to your callback_url via a multipart POST. No retrieval needed on your side.

Legacy API (add.shotbot.net): the URL can be derived locally from the MD5 of the submitted URL: https://static.shotbot.net/{md5[0]}/{md5[0:2]}/{md5}/{size}.jpg. Example for 120 px: https://static.shotbot.net/a/ab/abcdef.../120.jpg.

Full details in the API documentation and integration examples.

In Callback mode, Shotbot generates the screenshot and pushes it directly to your server via HTTP POST. No hosting on our side: images land on your infrastructure. Useful for high volumes, resellers, or white-label integrations. See the documentation.

Yes. Callback mode (white-label) is available for all accounts, including the free tier. Shotbot generates the screenshot and pushes it directly to your server via HTTP POST: no image hosted on our end, no Shotbot branding. No paid option required. See the callback documentation.

Yes. The API is available for personal and commercial use. For very high volumes (> 500,000 screenshots/month) or a dedicated SLA, contact us for a custom arrangement.

On our servers in France, managed by Permalink.

Screenshot URLs follow the format https://static.shotbot.net/{t1}/{t2}/{token}.{format} in APIv2 (random 32-hex token), or https://static.shotbot.net/{md5[0]}/{md5[0:2]}/{md5}/{size}.jpg in the legacy API (based on the MD5 of the submitted URL).

Yes. The Integration examples page has copy-paste code in PHP, Python, Node.js, Go, cURL, and Ruby, covering simple capture, callback mode (white-label with callback_secret verification), and batch mode (up to 500 URLs in one request).

The default limit for a batch is 500 URLs per POST /capture/batch request. If your volumes require it, contact us: the limit can be increased on your account on request.

It is an optional shared secret that secures callback mode. You pass it at submission (field callback_secret, ≤ 255 characters); Shotbot echoes it back as-is in the reception POST, in the callback_secret field. On your server side, you compare it with your expected value (using hash_equals() in PHP, subtle.ConstantTimeCompare in Go, etc.) to verify the incoming POST really comes from Shotbot.

Without this parameter, any attacker knowing your callback URL could POST a fake image to it. Recommended for any endpoint exposed on the internet. See the integration examples (PHP, Go, etc.).

As a complement, you can whitelist IP 163.172.105.112 in your firewall: all Shotbot callbacks originate from this address. Up-to-date JSON list.

To save your quota, the POST /capture/batch endpoint detects duplicates at two levels. Matching is by exact URL string (case-sensitive, including query parameters).

Within the batch: if the same URL appears multiple times in jobs[], only one screenshot is created and all occurrences return the same token.

Against recent screenshots: if the same URL was already submitted within the last 60 seconds by the same account (and is not yet complete), no new screenshot is created; the existing token is returned. Beyond 60 s, a new screenshot is created with a distinct token.

The response includes deduplicated (number of duplicates found) and submitted (actual new screenshots).

Shotbot attempts once to POST the screenshot to your callback_url, with a 30-second timeout. There is no automatic retry: if your server is down or responds too slowly, the capture is not redelivered (Shotbot stores nothing in callback mode). Callbacks should be treated as at-most-once delivery.

Recommendations:

Make sure your endpoint responds quickly (ideally < 5 s) and is highly available. Also verify that IP 163.172.105.112 is not blocked by your firewall (JSON list).

For large volumes or strict SLAs, use the hosted APIv2 (POST /capture) instead: Shotbot stores the image, you retrieve it at your own pace via polling or direct download.

You can monitor your callback log in your account dashboard.

Yes. The full APIv2 specification in OpenAPI 3.1 format is available at https://api.shotbot.net/openapi.yaml.

An interactive reference (Redoc, self-hosted - no external dependencies) is available at https://api.shotbot.net/docs.

The spec covers all endpoints (POST /capture, GET /capture/{token}, POST /capture/callback, POST /capture/batch), all parameters with their types, defaults and constraints, all error codes, and the free vs. Pro tier differences.

Both tools can import directly from an OpenAPI URL.

Postman: Import → Link → paste https://api.shotbot.net/openapi.yaml. A collection with all endpoints is generated automatically.

Insomnia: Create → Import → From URL → paste https://api.shotbot.net/openapi.yaml.

After import, set the key body variable to your API key (available on the API Key page).

Yes. Paste the OpenAPI spec URL into your tool's context.

Cursor / Copilot: reference https://api.shotbot.net/openapi.yaml in your context or attach it as a file.

Claude / ChatGPT: paste the URL and ask it to generate integration code in your language. The spec contains all parameters, types and error codes, so generated code is immediately usable without guesswork.

A plain-text summary is also available at https://www.shotbot.net/llms.txt, optimized for LLM context windows.

Pass viewport_width=1200, crop_height=630, and output_size=1200 in your APIv2 request. This produces an image exactly 1200×630 px regardless of the page's natural height, which is the standard Open Graph size.

crop_height is a Pro option. For OG images, format="webp" gives the smallest file; format="jpg" is the safest for email clients and older platforms.

If your page is purpose-built as an OG card (a /og/{slug} route rendered at 1200×630), you can skip crop_height and just use viewport_width=1200 + fullpage=false: the viewport height does the work.

Every APIv2 response with "status":"done" now includes a file_hash field containing the SHA-256 hash of the captured file, prefixed with sha256:.

To verify integrity, download the image and run:

sha256sum capture.jpg

This is useful for archiving, OSINT investigations, and any workflow where proving that a file has not been modified since capture matters.

captured_at is the Unix timestamp (seconds since 1970-01-01 UTC) of the exact moment the screenshot was taken. It is included in every "status":"done" APIv2 response.

Unlike the submission time, captured_at reflects when the browser actually rendered and saved the page, accounting for any time the capture spent in the queue. Convert it with new Date(captured_at * 1000) in JavaScript or datetime.fromtimestamp(captured_at) in Python.

This timestamp is useful for documenting the exact state of a page at a given point in time, for example in legal or compliance contexts.

No. The batch queue uses fair-share scheduling across customers: the next available worker is always assigned to the customer with the fewest batch captures currently running.

In practice: if you have 9,997 captures queued and another customer submits 3 URLs, their 3 captures will be processed first until they catch up to your level of in-flight activity. Once you are the only customer with queued captures, you get all the workers.

This mechanism protects every batch customer against large campaigns from a single account. If your volume justifies an exclusive queue with no sharing, see Shotbot Dedicated.

The batch endpoint (POST /capture/batch) handles this: up to 500 URLs per request (5,000 with Shotbot Pro). For a very large campaign (hundreds of thousands of captures in one run), let us know before you launch - we'll prepare capacity on your end to avoid any slowdown.

Yes. Pass a callback_url when submitting a capture: as soon as the render is ready, Shotbot posts the image file as multipart to your endpoint. A simple PHP handler (or any language) can then upload it to your bucket using the AWS SDK.

This works for single captures and for batches of up to 500 URLs: each completed capture triggers a separate POST to your handler.

See the full guide with ready-to-use code: Export screenshots to S3.

Any provider with an S3-compatible API works. The AWS PHP SDK (aws/aws-sdk-php) accepts an endpoint parameter that lets you point to any service:

• AWS S3: null endpoint (default behavior)


• Scaleway Object Storage: https://s3.fr-par.scw.cloud


• OVH Object Storage: https://s3.gra.io.cloud.ovh.net


• Cloudflare R2: https://<account_id>.r2.cloudflarestorage.com (no egress fees)


• Backblaze B2: https://s3.us-west-004.backblazeb2.com

Per-provider configuration examples are on the Export to S3 page.

Shotbot limits the number of captures running at the same time: 3 for free accounts, 15 for Shotbot Pro. When you exceed the limit, additional calls to POST /capture return 429 concurrency_limit.

The simplest fix: switch to POST /capture/batch. Batch submissions are not subject to the concurrency gate. You can submit up to 500 URLs in a single call, and Shotbot queues and processes them without triggering this error.

If you prefer to keep using the single-capture endpoint, add a retry loop with a short delay (1-2 seconds) when you receive a 429 response.

From your account dashboard, click "Top up". Payment is secured by Stripe. Credits are added automatically after confirmation (a few seconds). They do not expire.

Four one-time packs: 5,000 screenshots (€9.90), 20,000 screenshots (€14.90), 100,000 screenshots (€49.90), 500,000 screenshots (€199.00). Credits add to your monthly quota and do not expire. See the Pricing page.

Shotbot operates on a free monthly quota (200 screenshots) plus on-demand top-ups - no subscription, no commitment, no automatic billing. Shotbot Pro (€29/month or €290/year, 2 months free) is available for developers who need advanced features and priority processing.

No. Screenshot credits are non-refundable after purchase, in accordance with the terms and conditions. In case of a proven technical issue on our end, contact us.

No. Payment is entirely handled by Stripe, directly on their PCI-DSS Level 1 certified servers. Shotbot never sees your card details: only a confirmation notification via webhook.

VAT is not applicable (French auto-entrepreneur exempt under Art. 293 B of the French Tax Code). The displayed price is the final price.

Yes, and it is a deliberate choice. All our servers (API, workers, CDN, database) are hosted in France and managed by Permalink, a French managed hosting provider based in Strasbourg. Your data and screenshots do not leave French territory. Shotbot is subject to French law and GDPR: not to the US Cloud Act, not to a non-EU provider.

Email address, hashed password (bcrypt), IP address, session timestamps, and captured URLs. No banking data is stored on our servers. See our privacy policy for full details.

From your preferences, you can delete your account in self-service. Deletion is immediate: account data, sessions, preferences, and pending screenshots are removed.

What is retained after deletion: payment data is kept for 10 years (legal accounting obligation). Completed screenshot history may remain for up to 1 year after your last activity, then is deleted automatically. Image files on the CDN are removed within 30 days upon explicit request.

To exercise your GDPR rights with written acknowledgment (access, portability, rectification, objection), use our contact form. We respond within 30 days.

Screenshots are accessible via their CDN URL. They are not publicly listed or indexed by Shotbot.

In APIv2, the URL contains a random 32-character token that cannot be guessed, acting as a shared secret. In the legacy API, the URL is derived from the MD5 of the submitted URL, so it is deterministic and potentially predictable.

In all cases, anyone who knows the exact URL can access the image: do not submit confidential pages via the legacy API. For sensitive screenshots, use the APIv2 callback: the image is delivered directly to your server, never hosted on our side.

Detailed execution logs (processing steps, error messages) are kept for 30 rolling days, then deleted automatically. Your screenshot history (date, URL, options, status) remains visible in your account log as long as your account is active.

Yes. From your data export page, you can download all your personal data as a structured JSON file.

The file includes: your account information, preferences, your complete screenshot history (all captures, no date limit), scheduled screenshots, and payments.

This right is guaranteed by GDPR Article 20. If you need an export in a different format or a written confirmation, contact us via the contact form.

Via the contact form. We typically respond within 24 hours on business days.

Yes. Select the "Partnership" subject in the contact form and describe your project. We review all serious proposals: link exchanges, integrations, editorial partnerships.

Via the contact form, specifying the URL concerned. We process each report within 48 business hours.

Yes, three in fact. Three official open-source MIT clients are available: PHP, Python and Node.js, each a single file with no dependencies. Same flags, same exit codes, same UX: shotbot capture --url=https://example.com --output.

Pick whichever runtime you already have:
curl -fsSL https://api.shotbot.net/cli/php/shotbot -o shotbot && chmod +x shotbot (needs PHP 8.0+ and php-curl).
curl -fsSL https://api.shotbot.net/cli/python/shotbot -o shotbot && chmod +x shotbot (needs Python 3.8+, no pip install).
curl -fsSL https://api.shotbot.net/cli/node/shotbot -o shotbot && chmod +x shotbot (needs Node.js 18+, no npm install).

The binary is named shotbot in every case; drop it on your PATH or symlink it into /usr/local/bin/. Details on the CLI Tools page.

On first call, the CLI prompts for your API key (grab it from the API key page). It is saved with mode 0600 (readable only by your user), in a per-client file: ~/.shotbot-php-cli/config.json for the PHP client, ~/.shotbot-python-cli/config.json for the Python client, ~/.shotbot-node-cli/config.json for the Node.js client. The three coexist without conflict; defaults do not sync across clients.

In CI, or to switch between accounts, export SHOTBOT_API_KEY: it overrides the stored key. shotbot reset clears the saved key and re-prompts on the next call. shotbot config prints the path to the config file.

Yes, by default. Every CLI capture sets private: true on the request: the worker writes the file to a directory that nginx never serves, the CLI downloads it and saves it to your current directory (auto-named host-token.jpg), then the server-side copy auto-expires and is purged. No public URL is ever created.

This is useful for sensitive pages (intranets, dashboards, customer data) that you do not want cached on a public CDN. Use --output to choose where to save, or --cdn when you do want a permanent public URL on static.shotbot.net (no local file).

Yes. shotbot set <key> <value> persists an option that applies to every following capture. Per-call flags always win.

Examples:
shotbot set viewport 1440
shotbot set full-page
shotbot set output ./shots/
shotbot set format webp

shotbot defaults shows your stored values; shotbot defaults --keys lists every settable key with its type; shotbot unset <key> clears one. Defaults live in the same config.json as your API key.

Yes, every APIv2 option is available: --dismiss-cookies, --scroll, --block-ads, --crop-height, --selector, --http-auth-user / --http-auth-pass, plus PDF flags (--pdf-page-size, --pdf-margin, --pdf-scale, --pdf-landscape).

The CLI does no client-side gating; eligibility is enforced by the API. If your account is not Pro, the API returns 403 pro_required and the CLI exits with code 4. shotbot help lists every option with its allowed values.

Three things to know.

1. Export the key: export SHOTBOT_API_KEY=..., which skips the interactive prompt.
2. Disable color: set NO_COLOR=1 for clean logs.
3. Watch the exit codes: 0 success, 2 bad arguments, 3 network error, 4 API error, 5 waitlisted (quota exhausted), 6 capture failed on the server, 7 polling timeout.

--json emits the raw APIv2 response with no chrome, handy to parse the token, the file_hash, or the target HTTP status in a pipeline. --timeout=N caps polling for CI needs.

Shotbot ships an MCP server that gives Claude Code the ability to capture any page. One command installs it. No Node.js or npm needed:

claude mcp add --scope user shotbot --transport http "https://api.shotbot.net/mcp?key=your-key"

Run claude mcp list to confirm, then just ask Claude for a screenshot in plain language. Because Claude Code reads images, it can describe, compare, or critique what it captures. Full guide: claude-code-screenshots.

The MCP endpoint (https://api.shotbot.net/mcp) is capped at 5 requests per second per IP, with a burst allowance of 20. Normal usage (one tool call at a time) will never come close. For high-volume workflows (polling in a loop, chaining many captures), use the batch tool instead: it submits up to 500 URLs in a single atomic request and counts as one call.