How to Take a Full-Page Website Screenshot with Cloudinary

To capture a full page with Cloudinary, register the URL2PNG Website Screenshots add-on, use url2png as the delivery type, set the public website URL as the image public ID, and pass fullpage=true as a URL2PNG option. In production, generate the URL with a Cloudinary SDK so it is encoded and signed correctly, or generate the screenshot through Cloudinary’s authenticated explicit API.

1. Enable URL2PNG in Cloudinary

You need a Cloudinary account and access to the URL2PNG add-on. Register for it from the account’s Add-ons page. URL2PNG captures public website pages and makes the resulting image available through Cloudinary’s image transformation and delivery pipeline.

This method does not provide access to logged-in pages or bypass a site’s access controls. Do not place Cloudinary API secrets in browser-side code.

2. Build a full-page screenshot URL

The URL2PNG directive uses the target page URL as the public ID and appends screenshot options in this form:

<website-url>/url2png/<option=value>|<option=value>

For a full-page capture, set fullpage=true. Cloudinary’s documentation demonstrates the option with fullpage=false for a viewport capture; change the value to true for the full page. The exact Cloudinary delivery URL and signature depend on your cloud name, account configuration, target URL encoding, and SDK.

Conceptually, the URL2PNG portion looks like this:

<Cloudinary delivery URL>/image/url2png/<transformations>/<target-page-url>/url2png/fullpage=true

Treat this as a shape, not a copy-and-paste URL: nested target URLs must be encoded correctly, and the production URL generally needs a signature. Use the Cloudinary SDK URL helper rather than assembling the final URL by hand.

3. Choose how screenshot generation is authorized

Cloudinary protects add-on screenshot directives by default because an unplanned dynamic URL can trigger generation and cost. The documentation states: “By default, delivery URLs that use this add-on either need to be signed or eagerly generated.”

Method	When to use it	What happens
Signed delivery URL	Your application needs a screenshot on demand.	Your server uses the SDK to build a signed URL. The browser or client can then request that URL without receiving your API secret.
Authenticated eager generation	Your application decides when to create and store the screenshot.	Your server calls Cloudinary’s authenticated explicit API. After the screenshot version is generated, subsequent transformations can use regular unsigned delivery URLs.
Allow unsigned add-on transformations	Only when your security and cost controls support it.	An account setting can allow unsigned transformations, but this is not the default protection.

For a server-rendered application, keep credentials on the server and return a signed URL or the generated asset URL to the client. For a controlled batch or publishing workflow, eager generation gives your application a clear point to authorize and store each capture.

4. Set capture options for the target page

Cloudinary documents fullpage, viewport, user_agent, and delay among URL2PNG settings. Choose them based on the page and the image you need:

Option	Use	Considerations
fullpage=true	Capture the whole page instead of only the visible viewport.	Long pages produce taller images and may take longer to render or be less convenient to display.
viewport	Choose the browser viewport dimensions used for rendering.	Set dimensions that match the intended desktop or mobile layout; responsive breakpoints can change page content.
user_agent	Render with a user agent appropriate to the desired experience.	A mobile user agent may cause the site to serve a different layout. It does not grant access to restricted content.
delay	Wait before capture when a page needs time to render.	A delay can help with late-loading content, but it does not guarantee that every script, animation, or network request has completed.

Use an SDK helper for the complete URL so option separators and reserved characters in the target URL are handled correctly. Consult Cloudinary’s URL2PNG documentation for the current option syntax and CLI documentation for its generation workflow.

5. Deliver and transform the screenshot

Once generated, the screenshot is an image in Cloudinary’s delivery workflow and is cached and delivered through its CDN. You can apply image transformations for presentation, such as resizing or cropping, and other documented effects such as borders, overlays, and shadows. See Cloudinary’s transformation documentation.

Keep the original capture dimensions in mind when selecting transformations. A full-page image can be very tall; resizing it to a small thumbnail may make text unreadable. If a client needs only a preview, request a suitable transformation for that display size rather than downloading a very large image and scaling it in the browser.

Common problems and fixes

Symptom	Likely cause	What to check
Unauthorized or transformation rejected	The add-on is not registered, or the URL is unsigned and not eagerly generated.	Confirm URL2PNG registration. Generate a signed URL with the SDK or use the authenticated explicit API.
The capture shows only the visible area	The option is missing, misspelled, or set to fullpage=false.	Set the URL2PNG option to fullpage=true and verify it is attached to the screenshot directive.
The wrong layout appears	The viewport or user agent causes a different responsive layout.	Set the intended viewport dimensions and, if needed, a matching user agent.
Content is missing from the image	The page had not rendered that content when capture began, or the content requires authentication.	Try a suitable delay for render timing. URL2PNG is for public pages and does not access logged-in content.
Malformed URL or unexpected options	The nested target URL contains reserved characters that were not encoded correctly.	Build the URL with the Cloudinary SDK helper instead of concatenating strings by hand.
Unexpected generation or cost	A screenshot directive is being requested dynamically without the intended authorization and request controls.	Keep generation server-controlled, use signed URLs or eager generation, and review account settings before enabling unsigned transformations.

Performance, reliability, and cost considerations

• Full-page captures are larger: a long page can take more time to render and produce a larger image than a viewport capture. Choose the viewport and output transformation for the intended use.
• Rendering depends on the target: page scripts, delayed content, and responsive behavior affect the captured result. Use the documented delay, viewport, and user-agent options where appropriate, but do not assume a delay fixes every page.
• Delivery benefits from Cloudinary’s pipeline: generated screenshots are cached and delivered through its CDN, and can be transformed for downstream use.
• Protect generation: signed URLs and authenticated eager generation provide control over when add-on captures are requested. Unsigned generation is an optional account setting with security and cost implications.
• Check current add-on terms: URL2PNG tiers and volume plans can change. Consult the current Cloudinary account console before budgeting; a specific price is not required to implement this workflow.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server for developers. One GET request returns a PNG, JPEG, WebP, or PDF. Cookie banners are accepted and removed before capture, along with 60+ known consent platforms, newsletter popups, and chat widgets. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed; response headers report the page verdict and billing status. Its MCP server lets AI agents using Claude, Cursor, or another MCP client take screenshots.

To capture a full page, use the full_page parameter. The API accepts the parameter names used by other screenshot APIs as well. See the ScreenshotNeo API documentation for the full parameter reference.

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

import requests

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

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://stripe.com',
  full_page: 'true',
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const image = Buffer.from(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', image));

ScreenshotNeo includes full-page capture with lazy images loaded, selector capture, device presets, custom CSS and JavaScript, wait conditions, request blocking, caching, signed links, async jobs, bulk capture, and a usage API. All features are available on every plan. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots.

Sign up for ScreenshotNeo’s free plan to get 1,000 screenshots a month with no card.

FAQ

Can URL2PNG capture a page that requires a login?

The documented add-on is for public website pages. Do not use it to capture private pages or assume it can bypass access controls.

Does fullpage=true change Cloudinary’s authorization rules?

No. It requests a full-page capture; the add-on’s signing or eager-generation requirements still apply by default.

Can I resize a full-page screenshot after capture?

Yes. The screenshot can be delivered through Cloudinary’s image transformation workflow. Choose dimensions appropriate to the display so page details remain legible.

Should I use a signed URL or eager generation?

Use signed URLs for controlled on-demand generation. Use eager generation when your application should explicitly create the screenshot before serving it through regular delivery URLs.