For a faithful screenshot of a modern web page, have PHP control a real browser engine rather than trying to turn the page’s HTML into an image directly. Playwright PHP is a practical baseline: it opens the page in Chromium, waits for the content you need, then saves a viewport, full-page, or element screenshot. Spatie Browsershot offers a shorter PHP wrapper over Puppeteer; a dedicated Node.js Puppeteer worker is another option when your team already runs Node.
Why PHP needs a browser to screenshot a web page
A screenshot is an image of a page after a browser has rendered it: HTML, CSS, fonts, images, and JavaScript all contribute to what appears on screen. PHP can orchestrate the capture, but a browser engine is what renders the page. That distinction matters for JavaScript-heavy pages, where fetching HTML alone may return markup without the content a visitor sees.
Choose the capture scope to match the job. A viewport screenshot records the visible browser area; a full-page capture includes content below the fold; an element screenshot isolates a particular component. The Playwright PHP guide describes screenshots as answering “what did the page look like at this moment?” (Playwright PHP screenshots guide).
Choose a PHP screenshot approach
| Approach | Best fit | Trade-off |
|---|---|---|
| Playwright PHP | New PHP automation, tests, and jobs that need page, full-page, or element capture. | Requires PHP 8.2 or newer and Node.js 20 or newer per the Playwright PHP examples, plus an installed browser. |
| Spatie Browsershot | Laravel or general PHP code where a concise URL-to-image or HTML-to-image call is useful. | It wraps Puppeteer, so the deployment still needs the Node/Puppeteer/Chromium runtime expected by the version you choose. |
| Direct Puppeteer through Node | Teams already operating Node tooling that want the lower-level Puppeteer API. | PHP must communicate with a Node worker or service, adding process, deployment, and IPC complexity. |
For a new PHP implementation, start with Playwright PHP if you want the page and element screenshot APIs directly available from PHP. Prefer Browsershot when its wrapper fits an existing PHP or Laravel application. Use a separate Puppeteer service when running browser work in Node is already an acceptable operational choice.
#1 Best Overall
Set up Playwright PHP
The documented Playwright PHP examples list PHP 8.2+ and Node.js 20+ as requirements. Install the package in your project with Composer, then install the browser runtime using the package’s current setup instructions. The exact browser installation command can vary by package version and operating system, so follow the instructions for the version you install rather than relying on a command copied from an older setup.
- Check prerequisites. Confirm your PHP runtime is at least 8.2 and Node.js is at least 20.
- Install the PHP package. Add the Playwright PHP package with Composer using the installation instructions in its official documentation.
- Install Chromium. Install the browser binaries required by the selected package version and ensure the runtime user can launch them.
- Create an output directory. For example, create
artifactsin the project and ensure the PHP process can write to it. - Run a small capture. Start with a simple public page, verify the output image, then add authentication, waiting, or full-page capture as needed.
Capture a page with Playwright PHP
This minimal example opens a page in Chromium and saves the visible viewport to a PNG file. Run it from a PHP script in the Composer project after installing the package and browser.
<?php
use PlaywrightPlaywright;
$playwright = Playwright::create();
$browser = $playwright->chromium()->launch();
$page = $browser->newPage();
$page->goto('https://example.com');
$page->screenshot(__DIR__ . '/artifacts/example.png');
$browser->close();Use an absolute or project-relative destination that the PHP process can write to. For repeatable jobs, create the output directory before running the script and handle cleanup after artifacts have been uploaded or reviewed. In production code, put browser closure in a finally block so an exception during navigation or saving does not leave the browser process running.
Capture the full page
When the content below the fold matters, use the full-page screenshot option supported by the Playwright PHP screenshot API. The exact argument shape is defined by the installed library version; consult its screenshot guide for the option name and signature. Full-page output can be very tall on long pages, making it larger and slower to store or inspect than a viewport image.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Capture one element
When the target is a chart, card, invoice, or other component, locate that element and call the locator screenshot API rather than capturing the whole page. This reduces irrelevant content in the artifact. The selector must match the intended element after it has been rendered; wait for a stable selector before capturing if the page fills it asynchronously.
Rank #2
Wait for the right page state
A navigation completing does not necessarily mean a single-page application has finished drawing its useful content. Wait for a meaningful selector or the application state you need before capturing. If the page uses fonts, images, or delayed data, capture only after those dependencies have reached the state relevant to your task. Avoid arbitrary short waits as a substitute for a condition: they can be too short on a slow run and waste time on a fast one.
Use Browsershot from PHP
Spatie Browsershot gives PHP projects a compact URL-to-image or HTML-to-image API. Its repository documents this usage (Spatie Browsershot repository):
<?php
use SpatieBrowsershotBrowsershot;
Browsershot::url('https://example.com')
->save(__DIR__ . '/example.png');
Browsershot::html('<h1>Hello world!!</h1>')
->save(__DIR__ . '/example-html.png');The first call captures a URL; the second renders supplied HTML. Browsershot uses Puppeteer behind the scenes, so installing the PHP package alone is not the whole deployment: make sure the required Node, Puppeteer, and Chromium runtime is available to the process running PHP.
Free tools Windows power users keep installed
One-click scans. No signup required.
Use Puppeteer through a Node worker
Puppeteer’s Page.screenshot() API can return screenshot bytes as a Uint8Array or a base64 string. If your team already runs Node, PHP can hand a URL and capture options to a small worker and receive the resulting artifact or bytes. This is not a PHP-only solution: you must define how the worker is started, how PHP communicates with it, how errors and timeouts are returned, and where the browser runtime is installed.
Use this architecture when Node is already part of your deployment and you need its Puppeteer API. If you only need a PHP call to capture a page and do not want to operate a Node worker yourself, Playwright PHP or Browsershot is a more direct integration path.
Choose output format and capture settings
- PNG: a safe default for lossless text and interface screenshots.
- JPEG or WebP: can reduce file size where your capture API and downstream workflow support the format and its quality settings.
- Viewport: use when the visible fold is the evidence or preview you need.
- Full page: use when the whole document matters, while accounting for tall output on long pages.
- Element: use when a single component is the subject and surrounding page content is noise.
Set a deliberate viewport before capturing so responsive layouts render consistently. For logged-in pages, supply the required cookies or storage state in the browser context before navigation; otherwise the screenshot may show a login page or an unauthenticated version instead of the intended content. Keep credentials and session data out of the image artifact and out of logs.
Make screenshots reliable in tests and production
Screenshot correctness depends on more than the URL. Fonts, viewport dimensions, animations, page data, and browser version can all change rendered pixels. The Playwright PHP guide cautions that uncontrolled rendering environments can make image diffs test the machine rather than the product. For visual regression work, stabilize the environment and content before interpreting a pixel difference as a product change.
- Pin the browser environment: keep the browser version and runtime consistent across local development and CI.
- Fix the viewport: use the same width and height for comparable captures.
- Wait on content, not luck: wait for a selector or meaningful state rather than assuming a fixed delay is sufficient.
- Control animation and data: dynamic transitions and changing content can make otherwise identical runs differ.
- Store artifacts deliberately: write to a known CI-upload or application artifact directory, set retention or cleanup, and avoid capturing secrets or personal data.
- Set timeouts and surface failures: treat navigation and browser errors as failed jobs with useful logs, not as successful captures of blank or partial pages.
Troubleshoot common capture failures
Browser launch fails
Likely cause: Chromium is missing, inaccessible to the process user, or incompatible with the installed package setup. Fix: install the browser binaries required by the selected version, verify the PHP process can execute them, and check the runtime user’s permissions and environment.
The screenshot is blank or misses JavaScript content
Likely cause: capture occurred before the page populated its content, or the destination route needs authentication. Fix: wait for a page-specific selector or state, and initialize the browser context with the required cookies or storage state before navigation.
Fonts or layout differ between runs
Likely cause: different fonts, viewport dimensions, browser versions, animations, or data. Fix: make those inputs consistent in local and CI environments and wait for the page to settle before capturing.
Rank #4
The capture is truncated
Likely cause: a viewport screenshot was used when content below the fold was required. Fix: request full-page capture, or capture the relevant element if only one section matters.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Saving the file fails
Likely cause: the destination directory does not exist or the PHP process lacks write permission. Fix: create the directory as part of job setup, use a known writable path, and confirm the file exists before treating the job as complete.
CI is slow or leaves browser processes behind
Likely cause: browser startup and navigation take time, or an exception bypasses cleanup. Fix: reuse a browser where the library’s lifecycle permits it, avoid waiting longer than the required page state demands, and close browser resources in a guaranteed cleanup path.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Performance, reliability, and cost considerations
Local browser automation has a deployment cost: the browser and its runtime must be installed and maintained, and each capture consumes time and compute while pages load and render. Full-page captures of very long documents can increase output size. A worker service adds an operational boundary but can keep browser work separate from PHP request handling. For production workloads, avoid holding an interactive web request open unnecessarily; queue the capture, enforce a timeout, and store the result as an artifact when the product flow allows it.
There is no single cost or speed figure that applies to all PHP screenshot setups: resource use depends on the page, browser environment, capture dimensions, concurrency, and whether the browser is local or operated as a service. Measure your own representative pages and failure rates before sizing a production worker pool.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Or skip the browser setup
ScreenshotNeo is a website screenshot API and MCP server for developers. A single request returns a PNG, JPEG, WebP, or PDF; it can capture a URL without requiring you to install Chromium in your PHP application. Cookie banners and other known consent platforms, newsletter popups, and chat widgets are removed before the shot; each removal step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and the response includes X-Page-Verdict and X-Billed headers. Its 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 shots per month with no card; paid plans start at $5 for 3,000 shots. See ScreenshotNeo and the API documentation.
From PHP, make a GET request and save the response body as an image. Replace the target URL and supply your API key:
<?php
$apiKey = 'YOUR_API_KEY';
$url = 'https://example.com';
$query = http_build_query([
'access_key' => $apiKey,
'url' => $url,
]);
$ch = curl_init('https://api.screenshotneo.com/v1/shot?' . $query);
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 90,
]);
$image = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$error = curl_error($ch);
curl_close($ch);
if ($image === false) {
throw new RuntimeException('Screenshot request failed: ' . $error);
}
if ($status < 200 || $status >= 300) {
throw new RuntimeException('Screenshot API returned HTTP ' . $status);
}
file_put_contents(__DIR__ . '/artifacts/example.webp', $image);Keep the access key out of source control and check the response status before treating the body as a valid image. For a direct shell test with the same target URL, the documented cURL form is:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webpFor Python, use requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://example.com"}, timeout=90) and save r.content to a file. In Node.js, use const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com' }); const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);. ScreenshotNeo also supports full-page capture, CSS-selector element capture, device and viewport options, custom CSS and JavaScript, waits, headers, cookies, caching, signed links, async jobs, bulk capture, and other settings listed in its documentation.
Try the free plan: sign up for 1,000 screenshots a month with no card.
Frequently Asked Questions
Can PHP take a screenshot without installing a browser?
Not by itself for faithful rendering of modern web pages. Use a hosted screenshot API such as ScreenshotNeo if you want to avoid managing a local browser runtime.
Can PHP screenshot a JavaScript-rendered page?
Yes. Have PHP control a browser engine such as Chromium through Playwright PHP or Browsershot, and wait for the page state you need before capturing.
Which PHP approach is best for a Laravel application?
Browsershot is a concise PHP wrapper commonly suited to Laravel projects; Playwright PHP is another choice when you want its page and element capture APIs. Both require the relevant browser runtime.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteQuick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
