Best Free Mac Tools to Capture Website Screenshots in Bulk

For repeatable, free bulk website screenshots on a Mac, use Playwright if scripting is acceptable. It supports viewport, element, and full-page screenshots, multiple image formats, and high-resolution capture. For a no-code URL-list workflow, Shotomatic’s Website Capture page documents batch input and export, but its reviewed page does not confirm free pricing and batches must be started manually. Free browser tools such as Site-Shot and WebsiteScreen are documented for individual URLs, not list-based batches.

If you need a hosted screenshot API with a free monthly allowance, ScreenshotNeo is the first service to consider: cookie banners, popups, and chat widgets are removed before capture, and only clean shots are billed. The sections below compare local Mac workflows first, then show the hosted option.

1. Which tool fits your bulk screenshot workflow?

Tool	Best fit	Bulk workflow	Free caveat
ScreenshotNeo	Hosted API or AI-agent capture	Bulk API calls support up to 100 URLs per call; also offers async jobs	1,000 shots/month free without a card
Playwright	Developers who want a repeatable local script	Write a URL list and loop through it	Its screenshot docs describe capture capabilities; verify framework licensing separately if needed
Shotomatic Website Capture	Mac GUI and pasted URL list	Paste URLs, tune each page, run and export a batch	Reviewed workflow page does not establish price or a free trial; batches are manually started
Site-Shot browser tool	Occasional capture without installing software	Reviewed page documents one URL at a time	Free without signup; no reviewed evidence of a URL-list batch feature
WebsiteScreen browser tool	Occasional free capture in a browser	Reviewed page documents one URL at a time	Free without signup; no reviewed evidence of a URL-list batch feature
Screely	Polishing or redacting an existing screenshot	Post-capture editing, not URL-list capture	Free editor; not a bulk capture tool

Pick based on how you define “bulk.” A script that processes a file of URLs is repeatable and can be rerun, but requires coding and local browser setup. A GUI can reduce setup work, but confirm pricing and whether the batch is actually unattended. A free single-URL web tool is useful for occasional work, not evidence of a free batch workflow.

2. Capture a URL list locally with Playwright

Playwright’s screenshot documentation covers a viewport, a specific element, and the full scrollable page. It also documents PNG, JPEG, and WebP output, filenames, and CSS-pixel or device-pixel scale. See the official Playwright screenshots documentation. The basic example below captures each URL in a text file into its own PNG.

Install and prepare the URL list

mkdir bulk-shots
cd bulk-shots
npm init -y
npm install -D playwright
npx playwright install chromium

Create urls.txt, one complete URL per line:

https://example.com
https://developer.mozilla.org/
https://playwright.dev/

Runnable Node.js batch script

Save as capture.mjs. It skips blank lines and comments, uses a fresh page for each URL, records failures without stopping the batch, and writes a JSON report alongside the images.

import { chromium } from 'playwright';
import { readFile, mkdir, writeFile } from 'node:fs/promises';

const urls = (await readFile('urls.txt', 'utf8'))
  .split(/\r?\n/)
  .map(line => line.trim())
  .filter(line => line && !line.startsWith('#'));

await mkdir('screenshots', { recursive: true });
const browser = await chromium.launch({ headless: true });
const results = [];

try {
  for (const [index, url] of urls.entries()) {
    const page = await browser.newPage({ viewport: { width: 1440, height: 1000 } });
    try {
      const response = await page.goto(url, {
        waitUntil: 'domcontentloaded',
        timeout: 45000
      });
      await page.screenshot({
        path: `screenshots/${String(index + 1).padStart(4, '0')}.png`,
        fullPage: true
      });
      results.push({ url, status: response?.status() ?? null, ok: true });
    } catch (error) {
      results.push({ url, ok: false, error: String(error) });
    } finally {
      await page.close();
    }
  }
} finally {
  await browser.close();
  await writeFile('screenshots/report.json', JSON.stringify(results, null, 2));
}

Run with node capture.mjs. The numbered filenames preserve input order; use the report to map each result back to its URL. If stable descriptive names matter, derive filenames from a URL slug and add a collision-safe index.

Useful Playwright capture options

Need	Option or pattern	Notes
Viewport screenshot	`fullPage: false` (the default)	Captures the currently visible viewport.
Whole page	`fullPage: true`	Captures the full scrollable page; unusually long pages can consume substantial memory.
Element only	`await page.locator('main').screenshot({ path: 'main.png' })`	Use a selector that uniquely identifies the intended element.
JPEG or WebP	`type: 'jpeg'` or `type: 'webp'`	Use `quality` for lossy formats; PNG is lossless. Confirm format support for the installed browser version.
Higher resolution	`scale: 'css'` or `scale: 'device'`	Device scale can create larger images. Use CSS scale when file size matters.
Transparent background	`omitBackground: true`	Useful for PNG captures where the page background should be transparent.
Mask dynamic regions	`mask: [page.locator('.timestamp')]`	Useful for reducing visual differences caused by changing content.

For consistent captures of dynamic pages, add an intentional readiness condition rather than relying on a fixed delay for every URL. For example, wait for a page-specific selector with await page.locator('main').waitFor({ state: 'visible', timeout: 15000 }). Some pages never become network-idle because analytics or live connections remain open; choose a selector or a bounded delay for those pages.

Bulk script edge cases

Redirects: record the final page.url() if the destination matters.
HTTP errors: navigation can return a response with an error status without throwing; inspect response.status() and decide whether to save or flag the image.
Duplicate URLs: keep an index in filenames so captures do not overwrite one another.
Authentication: use a browser context with the appropriate cookies or storage state; do not put secrets in a shared URL list.
Consent dialogs: a local browser may show banners or overlays. The screenshot can include them unless the script handles the page or hides the elements.
Very large batches: the example is sequential to limit resource use. For faster runs, use a small fixed number of workers and monitor memory and target-site load.

3. No-code Mac capture with a URL list

Shotomatic’s Website Capture workflow documents a Mac GUI path: paste a list of URLs, set capture preferences per page, run the batch, review results, and export individual files or ZIP, PDF, or MP4 output. Its documented options include viewport or full-page capture, desktop/tablet/mobile sizing, waits, cookies, image format, and quality. The workflow page says batches are started manually and does not verify that the product is free. Check its current pricing and trial terms before choosing it for a free workflow.

Prepare one URL per line and decide whether you need viewport or full-page captures.
Set per-page dimensions, waits, cookies, and image format where required.
Start the run manually and review failed or incomplete pages.
Export individual images or an archive/document format that matches your downstream use.

This is the clearest documented GUI fit for pasted URL lists in the research reviewed. It does not establish unattended scheduling, so it is not a documented solution for recurring overnight capture.

4. Free browser tools for one-off screenshots

Site-Shot’s browser tool accepts a URL and documents PNG, JPEG, and WebP; full-page, viewport, and device emulation; and custom dimensions. Its product page lists a 20,000 px maximum full-page capture height and 16,383 px for WebP. The tool is free without signup, but the reviewed browser page does not establish URL-list batch capture. Its separate hosted API is paid: the official quickstart lists plans starting at $5/month for 2,000 screenshots and says there are no free API credits. Check current pricing before relying on those figures.

WebsiteScreen documents free browser capture without signup, including PNG/JPEG, viewport and full-page capture, device presets, and custom dimensions. Its reviewed browser page does not document a multi-URL list workflow. Treat it as a one-off tool unless its current product documentation confirms batching.

Screely is useful after capture for frames, annotations, blur or redaction, and PNG/PDF exports. It is an editor rather than a tool documented to capture a list of URLs.

5. Or skip the browser setup

ScreenshotNeo is a hosted website screenshot API and MCP server. One GET request takes a URL and returns PNG, JPEG, WebP, or PDF; the API also supports bulk capture for up to 100 URLs per call. Its API documentation covers the request options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Cookie and consent banners are accepted like a visitor and removed before the shot, along with 60+ known consent platforms, newsletter popups, and chat widgets; each cleanup step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and billing status. The MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.

The free plan includes 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 shots; higher tiers are $15 for 15,000, $39 for 60,000, $99 for 250,000, and $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan. A GUI or local script may fit better when you need local rendering or manual review; use a hosted API when you want repeatable requests without maintaining the browser setup.

Start with 1,000 free screenshots each month, with no card required.

6. Choosing capture settings for dependable batches

Viewport versus full page

Viewport images are smaller and make consistent side-by-side comparisons easier. Full-page shots preserve more content but can become very tall and memory-intensive. For visual checks across many pages, standardize the viewport, device scale, and wait condition. For content archives, full-page output may be more useful.

Wait strategy

Use the least expensive wait that produces the state you need. DOM content loaded is quick, but client-rendered content may not be ready. A page-specific selector gives a meaningful readiness signal. Network idle can be useful for static sites, but open analytics, polling, or streaming connections may prevent it from occurring. Fixed delays are simple, but slow pages can still be incomplete and fast pages waste time.

Local versus hosted rendering

Playwright renders in the browser installed on your Mac. This keeps the workflow under your control, but you manage browser installation, dependencies, execution, and output storage. Hosted tools render remotely and reduce local setup. The reviewed Site-Shot API documentation establishes hosted capture; consult each service’s current privacy and data handling terms for details rather than assuming how URLs, cookies, or screenshots are retained.

7. Performance, reliability, and cost

Limit concurrency: sequential captures are slower but predictable. If parallelizing, start with a small worker pool so Chromium memory use and requests to target sites stay controlled.
Use bounded timeouts and retries: retry transient navigation failures a limited number of times, with a delay between attempts. Do not retry every HTTP error blindly; a persistent 404 will not improve with retries.
Keep a manifest: record input URL, final URL, timestamp, status, output filename, and error. This makes reruns and audits safer than relying on filenames alone.
Reduce image size intentionally: viewport capture, CSS scale, and JPEG/WebP quality settings can reduce storage. Keep PNG for lossless output or when transparency matters.
Manage rate and access: respect target site terms and avoid sending a large burst of requests to one site. Some sites require authentication, block automation, or serve different content by region.
Separate capture cost from editing: Screely’s role is polishing captured images. Site-Shot’s browser page is free for individual captures, while its API is paid. Shotomatic’s reviewed workflow does not verify free pricing. ScreenshotNeo’s free allowance and tiers are listed above.

For cost planning, estimate the number of clean captures rather than the number of attempted URLs when using a service that reports billing outcomes. For local Playwright, there is no per-shot API charge established by the cited screenshot documentation, but the Mac still uses compute, storage, and maintenance time.

8. Troubleshooting

Symptom	Likely cause	Fix
Playwright says the browser executable is missing	Chromium was not installed for the current Playwright version	Run `npx playwright install chromium` in the project and rerun.
Navigation times out	Slow server, long-running requests, or an overly strict wait condition	Use a bounded timeout appropriate to the site and wait for a specific visible selector or DOM content instead of waiting for all network activity.
Screenshot is blank or missing rendered content	Capture occurred before client rendering completed, or the site returned an interstitial	Wait for a page-specific element, inspect the final URL and response status, and save an error record for the URL.
Cookie dialog or popup covers content	The site presents an overlay during capture	Handle consent in the browser context where permitted, or hide the overlay with a site-specific script. ScreenshotNeo removes known consent banners, popups, and chat widgets before capture.
Very tall full-page capture fails or consumes excessive memory	Large page dimensions and many loaded assets	Capture the viewport or key element, lower device scale, or split the capture if your workflow allows it.
Output files overwrite each other	Names are based on a non-unique URL slug or constant filename	Include the input index or a collision-safe identifier in every output filename.
Some pages fail while the batch stops	An uncaught navigation or screenshot error escaped the loop	Catch errors per URL, write them to a manifest, close each page in `finally`, and continue with later URLs.
Free web tool cannot accept the URL list	The reviewed product workflow supports individual capture only	Use Playwright or a documented URL-list GUI workflow; do not infer bulk support from an API mention alone.

9. Frequently asked questions

Can I run a screenshot batch automatically every day on my Mac?

A Playwright script can be launched by a local scheduler, provided the Mac is available and the browser environment is maintained. Shotomatic’s reviewed workflow requires users to start each batch manually and does not document unattended scheduling.

Playwright can use an authenticated browser context or saved storage state. Keep credentials and cookies out of source control and ordinary URL manifests. For hosted services, check the documented authentication and data handling behavior before sending private pages.

Should I save screenshots as PNG or WebP?

Choose PNG for lossless output and transparency. JPEG or WebP can reduce file size when lossy output is acceptable. Keep the same format and quality across a comparison batch.

Does “free” mean unlimited bulk capture?

No. A free single-page browser tool, a free local framework, and a hosted service’s monthly allowance are different offers. Check documented batch limits, pricing, and whether the workflow is manual or scheduled.