You can capture website screenshots from shared hosting only if your specific hosting plan lets your account launch Chrome or Chromium and provides the browser’s runtime requirements. If it does, use Puppeteer for scripted captures or Chrome’s headless command line for a simpler one-off job. If the host does not support browser processes, run the browser elsewhere, such as through a screenshot API.
Check whether your hosting plan can run a browser
A screenshot library does not render a website by itself: it needs a browser executable to load and paint the page. Installing Puppeteer is not proof that its compatible Chrome is installed or can run on your account. Puppeteer normally installs a compatible Chrome, and it can also be configured to use an explicitly specified executable; the host still has to permit and support that browser. See the Puppeteer configuration documentation.
Before building a capture script, ask your hosting provider about the exact plan and account. General cPanel documentation describes account facilities such as managing domains, website content, and databases; it does not establish whether a particular shared-hosting plan permits Chromium or what limits apply. See cPanel’s interface documentation.
- May scripts launch Chrome or Chromium processes on this plan?
- Is a compatible browser already available, or may you install one? If you must supply an executable path, what path is permitted?
- Are the browser’s required system libraries present, and will its sandbox work in this environment?
- What memory, CPU, process-count, and execution-time limits apply to browser jobs?
- Which locations can the browser write to for screenshots, temporary files, its profile, and cache?
- How can a generated file be retrieved or served, and are scheduled or background processes permitted?
Puppeteer’s troubleshooting guidance calls out system dependencies, sandbox conditions, and writable browser profile and cache locations as runtime considerations. A shared host may restrict any of them; confirm the provider’s answer rather than assuming a local development setup will work. See Puppeteer troubleshooting.
#1 Best Overall
Capture with Puppeteer when Node.js and Chrome are supported
Puppeteer is the better fit when you need repeatable captures, a chosen viewport, full-page output, clipping, or other browser-driven steps. Its Page.screenshot() method returns screenshot data. Set path to save the result: a relative path resolves from the process working directory, and omitting path does not save a file to disk by itself. The API also supports output type and capture options such as fullPage and clipping. Check the current Page.screenshot API reference for the installed Puppeteer version.
Install and run a basic full-page capture
On a host that permits the installation and launch of the browser, create a Node.js project and install Puppeteer:
- In the project directory, run
npm init -y. - Run
npm install puppeteer. Puppeteer’s default installation downloads a compatible Chrome, which may be disallowed or impractical on some shared hosts. - Save the following as
capture.cjs, replacing the example address with the page you are authorized to capture. - Run
node capture.cjsfrom that directory, then check forwebsite.png.
const puppeteer = require('puppeteer');
(async () => {
const browser = await puppeteer.launch({ headless: true });
try {
const page = await browser.newPage();
await page.setViewport({ width: 1440, height: 900 });
await page.goto('https://example.com', { waitUntil: 'networkidle2' });
await page.screenshot({ path: 'website.png', fullPage: true });
} finally {
await browser.close();
}
})().catch((error) => {
console.error(error);
process.exitCode = 1;
});This script writes to the current working directory, so run it from a location your account can write to. If Puppeteer cannot find its downloaded browser, check whether installation completed and whether the runtime account can access the browser cache. If the host supplies a browser at a different path, Puppeteer configuration supports specifying an executable path; use the provider-approved path rather than guessing.
Choose full-page, viewport, or clipped output
fullPage: trueasks Puppeteer to capture the full page rather than only the visible viewport. Long or dynamically changing pages can take more resources and may not have loaded all lazy content at navigation completion.- For a viewport-only image, omit
fullPageor set it tofalse; the viewport dimensions are set withpage.setViewport(). - Use the screenshot API’s clipping option when you need a defined rectangle rather than the entire page. Review the API reference for the exact option shape supported by your installed version.
- Set the screenshot output type and a writable
pathwhen you need a format or destination other than the basic PNG in the example.
For pages whose content appears after initial navigation, wait for a page-specific selector or an appropriate delay before capturing. Do not assume that a network-idle condition means every image or client-side widget has finished rendering; test the target page and choose a wait condition that matches it.
Rank #2
Use Chrome’s command line for a simple capture
If Chrome or Chromium is installed and runnable, its headless command line can capture a screenshot without writing a Node.js script. Chrome documents --screenshot and --window-size; its example writes screenshot.png in the current working directory. See Chrome for Developers’ headless documentation.
chrome --headless --window-size=1440,900 --screenshot="screenshot.png" "https://example.com"Replace chrome with the executable name or full path the hosting provider makes available. Run the command from a directory writable by your account. The chosen window size sets the capture viewport; this command is not a substitute for Puppeteer when you need scripted page interaction, selector-based waits, or programmatic handling of many captures.
Save and retrieve the image safely
A successful browser run is only useful if the output lands somewhere your account can access. Use an explicit writable location if the process working directory is uncertain, and verify that the file exists and has nonzero size after the command finishes. Keep browser profiles and temporary data in locations the provider permits; do not assume the account’s public web directory is an appropriate location for temporary browser data. If the image must be public, move or copy the finished file to the intended web-accessible location using the provider’s allowed workflow.
For repeated or scheduled captures, confirm that the plan permits the required processes and runtime duration, and account for browser startup, page loading, and image writing within those limits. No general guidance specifies limits for a particular hosting company or plan, so obtain those values from your provider.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →When local capture is not supported
If the provider will not allow Chromium, lacks required libraries, or imposes limits that make browser jobs impractical, the shared account is the wrong place to run the browser. Use a local machine, another server or browser environment you control, or a hosted screenshot API. Before choosing an external service, check its current terms, privacy handling, supported capture controls, reliability information, and price directly; those vary by provider and are not established by shared-hosting documentation.
When comparing a browser on your host with an external service, weigh provider permission and setup effort against control over viewport, full-page capture, page interaction, available resources, and how the resulting file is delivered. A service can avoid installing a browser on the shared host, but it means sending a URL and capture request to another system; consider what the target page exposes and whether that handling suits your use.
Or skip the browser setup
ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. Its clean-shot process accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and responses include X-Page-Verdict and X-Billed headers.
Make a one-call request from a machine that can reach the API. The following cURL example saves a WebP image; replace the URL with the page to capture and supply your API key. See the ScreenshotNeo documentation for request options and response details.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webpPython and Node.js alternatives:
import requests
r = requests.get(
"https://api.screenshotneo.com/v1/shot",
params={"access_key": "YOUR_API_KEY", "url": "https://example.com"},
timeout=90,
)
open("shot.webp", "wb").write(r.content)const q = new URLSearchParams({
access_key: 'YOUR_API_KEY',
url: 'https://example.com'
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);The API can return PNG, JPEG, WebP, or PDF, and offers controls including full-page capture, viewport and device presets, selector capture, waiting, custom CSS or JavaScript, and request blocking. 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 without a card; paid plans start at $5 for 3,000 shots. Clean banners and popups are removed before the shot, failed or blocked captures are not billed, and AI agents can take screenshots through MCP. Sign up for 1,000 free screenshots a month with no card.
Troubleshooting shared-host screenshots
“Browser not found” or launch fails immediately
Puppeteer may be installed without an accessible compatible browser, or its browser download may not be available in the host environment. Confirm installation completed, check the configured browser cache and executable path, and ask whether the provider supplies an approved Chrome or Chromium binary. Puppeteer documents its browser configuration at its configuration guide.
Missing shared libraries or a sandbox error
These are environment constraints, not screenshot-option mistakes. Puppeteer lists system dependencies and sandbox conditions among troubleshooting concerns. Ask the host whether required libraries and launch conditions are supported; do not try to bypass provider security restrictions. If they cannot support the browser, capture elsewhere.
Permission denied while saving
The browser process cannot write to the selected destination, or the process is running under a different account than expected. Choose a directory the job’s account can write to, and verify the working directory and file permissions. Puppeteer resolves relative screenshot paths from the process working directory.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesThe screenshot is blank, incomplete, or missing late-loading content
Check that navigation reached the intended page and that the capture waits for the page’s actual content. A fixed viewport can omit content below the fold; use full-page capture when that is the goal. For client-rendered or lazy-loaded pages, wait for a meaningful selector or a suitable delay, and verify the result on the target page rather than relying only on network-idle navigation.
The job times out or is killed
Browser startup and page rendering can exceed a shared host’s process or execution-time limits, and full-page captures may require more work than viewport captures. Check the provider’s time and resource limits and inspect the host’s job or application logs if available. Reduce unnecessary captures or use a separate browser environment if the permitted limits are insufficient.
The command works locally but not on the shared host
Local and hosted environments may differ in installed libraries, browser availability, sandbox support, filesystem permissions, and resource limits. Recheck each with the provider for the specific plan; general cPanel interface documentation cannot establish these details for an unspecified account.
Frequently Asked Questions
Does cPanel itself include a website screenshot tool?
The cPanel interface documentation covers account management, not a general browser screenshot feature. Whether a host adds its own tool depends on that provider.
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 matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCan I capture a page that requires a login?
Only if the browser environment can authenticate appropriately and you are authorized to access the page. Do not expose credentials in public scripts or output; ask the host how it protects environment secrets.
Should I use full-page capture for every screenshot?
No. Use it when content below the initial viewport matters; viewport capture is usually more appropriate when you need to represent what fits on screen.
Quick 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.
