Take a website screenshot — desktop, mobile, full page, or viewport. Free, no signup.

Six independent configuration axes — each one tweakable, each one with sensible defaults. Most captures don't need to touch the advanced options; the ones that do are usually about wait time or user agent.

A screenshot of a website is a frozen moment of public state — useful in any workflow where the live URL can change, vanish, or refuse to render the same way later. Five recurring needs:

• Document evidence Capture how a page looked at a specific moment — for compliance audits, takedown disputes, regulatory archives, or competitive intelligence. The live URL may change tomorrow; the PNG is permanent.
• Generate marketing assets Open Graph images, Twitter Card previews, blog hero shots, documentation thumbnails — every modern content stack ends up needing programmatic screenshots somewhere in the pipeline.
• Visual regression in QA Compare today's screenshot of a UI against last week's. Catches CSS drift, broken layouts, font swaps, and accidental visual regressions before users notice.
• Cross-device verification See how your site renders on a 375px iPhone or a 1920px desktop without owning the device. Catch responsive bugs and mobile-only routing issues in one pass.
• AI vision context Feed screenshots to GPT-4V, Claude, or Gemini when text scraping alone misses layout, branding, or visual hierarchy. Increasingly common in research, scraping, and agent workflows.

Each request gets a fresh, isolated headless Chrome instance. No persistent state, no shared cookies, no leakage between captures. The pipeline runs at the edge to minimize round-trip latency to the target.

• Stage 1 — Provision the browser Spin up a clean Chromium instance with the requested viewport and user-agent. No history, no extensions, no third-party cookies.
• Stage 2 — Navigate to the URL Issue the navigation, wait for the `load` event. Network and JavaScript execute as they would in a real user's browser.
• Stage 3 — Wait after load Pause for the configured wait time (default 1s). Gives SPAs time to hydrate, lazy-loaded images time to appear, and animations time to settle.
• Stage 4 — Capture For viewport mode, screenshot the visible area. For full-page mode, scroll and stitch — handling sticky headers and lazy-load triggers along the way.
• Stage 5 — Encode and return Encode in the requested format at the requested quality. Return the binary directly, or a hosted URL plus metadata if JSON output is requested.

Defaults work for most cases. These are the levers you'll reach for when defaults don't:

• URL — required The page to capture. Must be a fully-qualified URL (https://example.com, not example.com). URL-encode any query parameters so the parser doesn't truncate them.
• Device Type — Desktop (default) or Mobile Sets a baseline viewport (Desktop: 1920×1080; Mobile: 375×667) and toggles touch event emulation. Mobile mode sends Mobile Chrome as the user agent automatically. Switch when you want to verify how a site renders on a phone vs a laptop.
• Capture Mode — Visible Viewport (default) or Full Page Visible Viewport captures only the area inside the viewport — predictable dimensions, faster. Full Page scrolls and stitches the entire document. Use Full Page for OG images of landing pages and for archiving long articles. Skip Full Page on sites with sticky headers (they repeat at every scroll step).
• Viewport Width — 1920 / 1366 / 1024 / 768 / 375 / custom Common presets: 1920 (modern desktop, default), 1366 (legacy laptop — still ~30% of desktop traffic), 1024 (small laptop / large tablet), 768 (tablet portrait), 375 (iPhone). Custom accepts any pixel value.
• Viewport Height — 1080 (default) or custom Only meaningful in Visible Viewport mode — in Full Page mode, the actual document height overrides this. Set this when you need a specific aspect ratio (e.g., 1200×630 for a Twitter Card, 1080×1080 for Instagram).
• Image Format — PNG (default), JPEG, or WebP PNG: lossless, larger files (often 5–10× JPEG), perfect for UI with sharp text. JPEG: smaller, lossy, best for photo-heavy pages — quality control applies here. WebP: best size-to-quality ratio but check downstream compatibility (older email clients, some social previews still want PNG/JPEG).
• Image Quality — 90% (default) Only applies to JPEG and WebP. 90% is the sweet spot for most use cases. Drop to 70–80% for OG images where size matters more than fidelity. Ignored entirely for PNG (it's lossless).
• Wait Time After Load — 1s (default), 0–30s Time to wait after the page's load event before capturing. Increase to 3–5s for SPAs that hydrate after first paint, sites with lazy-loaded images, or pages with intro animations. Decrease to 0 only if you're confident the page is fully rendered at load (rare in 2026).
• User Agent — Default Browser / Mobile Chrome / custom Default Browser sends a modern Chrome UA. Mobile Chrome simulates a phone. A custom string can simulate Googlebot, GPTBot, or a specific browser version — useful for verifying that what bots see matches what users see (or doesn't, deliberately, for cloaking detection).

Capture quality depends on how the target site behaves. Some sites resist capture; some need coaxing. Common gotchas and their fixes:

• Screenshot is blank or partial Most often the site lazy-loads content after the load event. Bump the wait time to 3–5 seconds. If the page renders client-side (React/Vue/Svelte SPA without SSR), you may need 5–10 seconds for full hydration.
• Cookie banners cover the content Some banners auto-dismiss on second visit but appear on first; since each capture is a fresh browser, the banner shows up every time. Workaround: use a longer URL with a cookie-accepting query parameter if the site supports it, or capture below-the-fold via Full Page mode.
• CAPTCHA or bot-protection page appears Sites behind Cloudflare Bot Management, reCAPTCHA, or DataDome will sometimes serve a challenge instead of the real page. Try a custom user agent that matches a real desktop Chrome version, but recognize this is fundamentally a bot/anti-bot game — some sites simply won't render.
• Animations are captured mid-frame Hero animations, loading spinners, fade-ins — if the wait time is shorter than the animation duration, you'll catch them in motion. Increase wait time, or capture an element with a known final state.
• Sticky headers repeat in Full Page mode A header with `position: fixed` or `position: sticky` will appear at every scroll position during the stitching process. There's no clean fix — capture in Viewport mode if the duplication matters, or capture and crop in post.
• Geo-restricted content shows the wrong region Captures originate from our edge nodes (US/EU). If the page localizes based on IP, you'll see the region the edge node serves, not the region you're querying from. For specific geo testing, run your own headless browser from a regional proxy.
• Very long pages get cut off Full-page captures have a hard limit of 16,384 pixels in height (Chrome's max canvas size). Pages longer than that are truncated. Split the capture into sections, or use Viewport mode and scroll manually.
• Authenticated pages aren't supported The free tier captures public URLs only — no login flow, no session persistence. For authenticated capture, run your own Puppeteer/Playwright instance with stored cookies.

The API returns either the binary image directly (default) or JSON with a hosted image URL and metadata. Free tier is rate-limited per IP. For OG image pipelines and other production use, request an API key.

# Save the screenshot directly
curl -o screenshot.png \
  "https://api.domainscan.in/v1/snapshot?url=https%3A%2F%2Fgithub.com"

# With options
curl -o screenshot.webp \
  "https://api.domainscan.in/v1/snapshot?url=https%3A%2F%2Fgithub.com&device=mobile&format=webp&fullPage=true&wait=3"

curl "https://api.domainscan.in/v1/snapshot?url=https%3A%2F%2Fgithub.com&output=json"

# Returns:
# {
#   "imageUrl":    "https://cdn.domainscan.in/snap/abc123.png",
#   "format":      "png",
#   "device":      "desktop",
#   "viewport":    { "width": 1920, "height": 1080 },
#   "captureMode": "viewport",
#   "dimensions":  { "width": 1920, "height": 1080 },
#   "fileSize":    458291,
#   "capturedAt":  "2026-05-19T00:00:00Z",
#   "renderTime":  2.34
# }

const res = await fetch(
  'https://api.domainscan.in/v1/snapshot?' +
  new URLSearchParams({
    url:      'https://github.com',
    device:   'desktop',
    format:   'png',
    fullPage: 'true',
    wait:     '2'
  })
);
const blob = await res.blob();

// In a browser: trigger download
const dlUrl = URL.createObjectURL(blob);
Object.assign(document.createElement('a'), {
  href: dlUrl,
  download: 'screenshot.png'
}).click();

// In Node: write to disk
// const buf = Buffer.from(await blob.arrayBuffer());
// await fs.writeFile('screenshot.png', buf);

import requests

r = requests.get(
    'https://api.domainscan.in/v1/snapshot',
    params={
        'url':      'https://github.com',
        'device':   'desktop',
        'format':   'png',
        'fullPage': 'true',
        'wait':     '2'
    },
    stream=True
)

with open('screenshot.png', 'wb') as f:
    for chunk in r.iter_content(8192):
        f.write(chunk)

{
  "url":       "string (required, URL-encoded)",
  "device":    "desktop | mobile  (default: desktop)",
  "fullPage":  "true | false      (default: false)",
  "format":    "png | jpeg | webp (default: png)",
  "quality":   "1–100             (default: 90, ignored for png)",
  "wait":      "0–30 seconds      (default: 1)",
  "width":     "integer pixels    (default: 1920 / 375)",
  "height":    "integer pixels    (default: 1080 / 667)",
  "userAgent": "string             (default: modern Chrome)",
  "output":    "binary | json     (default: binary)"
}

Six workflow patterns we see most often:

What this tool is good at: fast, ad-hoc captures with sensible defaults, accessible via a free public API. What it isn't trying to be: a fully managed visual-regression suite, an authenticated-capture engine, or a production-grade screenshot service with an SLA. Pick deliberately:

• Authenticated screenshots → run your own Puppeteer / Playwright Need to log in, navigate behind a paywall, or persist cookies across captures? Roll your own. Puppeteer and Playwright both expose first-class APIs for this; this tool intentionally doesn't.
• Visual regression at scale → Percy, Chromatic, BackstopJS If you're running thousands of visual diffs per day with stored baselines, review workflows, and team approvals — use a tool built for that. This tool gives you the captures; it doesn't store, compare, or review.
• High-volume production with SLAs → URLBox, ApiFlash, Screenshotmachine Paid services with dedicated infrastructure, contractual uptime, and per-region edges. If a single missed capture costs you money, pay for guarantees.
• DOM extraction, not pixels → scraping libraries If you want the page's text, structured data, or HTML — not how it looks — use Cheerio, Playwright's content APIs, or readability extractors directly. Screenshots are an inefficient substitute.
• Browser automation → Playwright / Selenium Clicking, scrolling, form-filling, multi-step flows — that's automation, not capture. This tool takes one screenshot per request and stops. For everything before the screenshot, you need a full browser-automation framework.
• When ad-hoc capture is enough → this tool No setup, no install, no infra to maintain. Free for casual use, API-accessible for light automation. The right fit when you need a screenshot and don't need everything else.

• Why is my screenshot blank or partial? Almost always a wait-time issue. The page hadn't finished rendering when the capture fired. Bump wait time to 3–5 seconds. For client-rendered SPAs, sometimes 5–10. If the page still doesn't appear, the site may be blocking headless browsers entirely (see CAPTCHA question below).
• Can I capture pages that require login? Not on the free public tier. Each request gets a fresh, isolated browser with no cookies and no session. For authenticated capture, run your own Puppeteer/Playwright instance with persisted cookies, or use a paid service with a session-management feature.
• What's the best image format for OG images and social previews? JPEG at ~85% quality is the safest default — broad compatibility across Facebook, LinkedIn, Twitter/X, Slack, and email previews. PNG is fine but ~3–5× larger. WebP is best size-to-quality but some older preview consumers still don't render it. If in doubt, JPEG.
• How big can a full-page screenshot be? Width is whatever you set as viewport width. Height is capped at 16,384 pixels — Chrome's maximum canvas dimension. Pages taller than that are truncated. If you need a complete capture of a very long page, split into multiple viewport-mode captures and stitch downstream.
• Can the tool bypass cookie banners and CAPTCHAs? Cookie banners — usually no, since each capture starts with a fresh cookie jar. CAPTCHAs and bot-protection challenges — definitely no. Sites behind Cloudflare Bot Management, reCAPTCHA, or DataDome will sometimes serve a challenge page; we capture what's served. That's by design — we don't try to defeat anti-bot systems.
• Is there a screenshot API? Yes — every option on this page is exposed as a query parameter. See section 06 for cURL, JavaScript, and Python examples. The API returns either the raw image bytes (default) or JSON with a hosted image URL plus metadata.
• Are captures stored or shared? When you request `output=json`, the image is uploaded to our CDN and the URL is returned to you — it lives there for 24 hours, then is deleted. When you request binary output (the default), nothing is stored server-side. We don't share captured images with third parties under any circumstances.
• How is this different from URLBox or ApiFlash? URLBox and ApiFlash are paid, production-grade services with SLAs, regional edges, session management, and dedicated support. Worth the money for production workloads. This tool is free, fast, and adequate for ad-hoc work, OG image generation, light automation, and developer testing. Use whichever matches your reliability needs.