# Full Page Screenshot and PDF Generator for Many URLs

> Full page screenshot or PDF for up to 200 public URLs. Desktop, tablet or mobile screen, cookie banners closed. One row per page with file link.

URL: https://cliqtomedia.com/actors/website-screenshot-pdf/

Category: AI-ready content & documents · Status: live on Apify Store · Apify page: https://apify.com/cliqtomedia/website-screenshot-pdf?fpr=cliqto

Make full-page pictures or PDFs of a list of web pages. Cookie banners are closed and lazy images are loaded first. You can pick a phone, tablet or desktop screen.

## How to use it: 3 steps

1. **Make a free Apify account.** Apify is the cloud platform where our tools run. The free plan gives you $5 of usage every month, no credit card needed. You pay Apify, not us.
2. **Paste your input and press Start.** No code needed: you fill in a form (the input). It already has a working example. For example: `https://apify.com` in Website URLs. Each start is one run.
3. **Download the results.** When the run ends, the results are in a table (the dataset). Open Output, press Export and pick Excel or CSV. JSON and the API are there too.

## What it does

Take full-page screenshots (PNG or JPEG) or PDFs of a list of public web pages. Cookie banners are closed for you, and you can pick a desktop, laptop, tablet, mobile or custom screen. Each page gets one Dataset row with a link to the file, its size, the page title, the HTTP status and a clear error code if something went wrong. No login needed.

- Waits until the page has loaded (you choose how: `load`, `domcontentloaded`, `networkidle` or a CSS selector).
- Closes the cookie consent banner. It uses the open-source Autoconsent rules, which know more than 200 consent tools such as OneTrust, Cookiebot, Didomi, Quantcast and Sourcepoint. It clicks "reject" or "save choices" when it can. Anything left is hidden with cosmetic filters.
- Scrolls down the page so lazy images load, then goes back to the top.
- Saves a full-page PNG or JPEG, a screenshot of the first screen only, or a PDF.
- Stores the file in the run's Key-value store and writes one Dataset row with the file link and page details.

### Good for

- Visual archive of your own or competitors' landing pages, every day or week.
- Mobile and desktop screenshots of the same page, for design and QA checks.
- PDF copies of articles, policies and terms pages for records.
- Screenshots for reports, link previews or AI agents that need to "see" a page.
- Drop-in input for the `apify/screenshot-url` example Actor: its fields `urls`, `waitUntil`, `delay`, `viewportWidth`, `scrollToBottom`, `selectorsToHide` and `proxy` are accepted as they are.

### Not a good fit

- Pages behind a login. The Actor does not sign in, does not use your cookies and does not solve CAPTCHAs. A login or "access denied" page is captured as it is, with a warning.
- Some sites block cloud browsers (for example some big news sites answer HTTP 401 or 403). You get a screenshot of what the site shows, plus a warning with the HTTP status.
- Very long pages are cut at `maxFullPageHeight` (15,000 px by default, 30,000 px max) and the row has `truncated: true`.
- No video, GIF or animation recording. Animations are stopped before the screenshot.
- Local and private addresses (`localhost`, `192.168.x.x`, `10.x.x.x` and similar) are blocked.

## Price

Pay per event. Apify bills you, not us.

| What you pay for | Price | When |
|---|---|---|
| Start fee | $0.003 | Charged once per run, one fee per GB of memory. This tool uses 4 GB by default, so $0.012 per run. |
| Page captured | $0.015 (from $0.013 on paid Apify plans) | One saved screenshot (PNG or JPEG) or PDF of a web page. Failed, skipped and unprocessed URLs are not charged. |
| Extra wait | $0.006 | Add-on per captured page when waitFor is networkidle or delayMs is above 0: the browser stays busy for longer. Not charged with default settings. |

- One capture: about $0.03.
- 1,000 captures: about $15.01.
- Every day 100 captures, for 30 days: about $45.36 a month.

Free to try: the Apify free plan gives you $5 of usage every month, no credit card needed.

Prices checked on 24 October 2026. Current price: https://apify.com/cliqtomedia/website-screenshot-pdf?fpr=cliqto

## Questions

### Does it capture the whole page?

Yes, full page is the main mode. It scrolls down first so images load.

### Can I save a page as PDF?

Yes. Choose PDF instead of PNG or JPEG.

### Do I pay for broken links?

You pay per saved file. Invalid URLs and unknown domains never open a browser.

### Can it capture pages after login?

No. It does not sign in. A login page is saved as it is, with a warning.

### Can it screenshot pages that need a login?

No. It does not sign in and does not accept cookies or passwords. Only public pages.

### Do I pay for failed URLs?

No. Only saved files are charged, plus the small start fee.

### How long are the files kept?

They live in the run's default Key-value store, as long as your Apify plan keeps run storage. Download or copy them if you need them longer.

### Is the full page always captured?

Up to `maxFullPageHeight`. For very long pages with many elements (for example long Wikipedia articles) the Actor makes the browser window as tall as the screenshot instead of scrolling; elements sized to the screen height may then look taller, and the row has a warning.

### Can I use it instead of `apify/screenshot-url`?

Yes for input: its fields are accepted unchanged, within our limits (`delay` up to 5000 ms, up to 200 URLs). A network-idle `waitUntil` (their default is often `networkidle2`) or a `delay` above 0 adds the extra-wait add-on; use `load` and no delay for the base price. The output names differ: use `url` (their `startUrl`), `fileUrl`/`screenshotUrl` (their `screenshotUrl`) and `kvsKey` (their `screenshotKey`).

## Data fields

- `url` (string): URL as given in the input.
- `finalUrl` (string): URL after redirects; null when the page did not load.
- `status` (string): success when a file was saved; failed otherwise (see errorCode).
- `statusCode` (integer): HTTP status of the main page, e.g. 200 or 404.
- `format` (string): Output format of this run.
- `fileUrl` (string): Public link to the saved file (image or PDF) in the run key-value store.
- `screenshotUrl` (string): Same as fileUrl for PNG/JPEG; null for PDF.
- `pdfUrl` (string): Same as fileUrl for PDF; null for images.
- `kvsKey` (string): Key of the file in the run key-value store, e.g. capture-0001-apify.com.png.
- `contentType` (string): image/png, image/jpeg or application/pdf.
- `bytes` (integer): File size in bytes.
- `width` (integer): Image width in pixels (CSS width × pixel density); null for PDF.
- `height` (integer): Image height in pixels; null for PDF.
- `pageHeight` (integer): Full scrollable page height in CSS pixels at capture time.
- `truncated` (boolean): True when a very long page was cut at the maximum height.
- `pdfPages` (integer): Number of PDF pages; null for images.
- `title` (string): Page <title>.
- `viewport` (string): Device preset: desktop, laptop, tablet, mobile or custom.
- `viewportWidth` (integer): Viewport width in CSS pixels.
- `viewportHeight` (integer): Viewport height in CSS pixels.
- `deviceScaleFactor` (integer): Pixel density used (1 or 2 usually).
- `fullPage` (boolean): True for a full-page image.
- `cookieBanner` (object): Cookie consent handling: detected (pop-up shown), cmp (consent manager name), handled (rejected/closed). Null when hiding is off or the page failed.
- `warnings` (array): Non-fatal notes, e.g. the page was cut or a load event was late.
- `loadTimeMs` (integer): Time from navigation start to capture, in milliseconds.
- `takenAt` (string): Capture time (ISO 8601, UTC).
- `errorCode` (string): INVALID_URL, BLOCKED_URL, DNS_ERROR, CONNECTION_FAILED, NAVIGATION_TIMEOUT, SELECTOR_NOT_FOUND, NOT_A_WEB_PAGE, CAPTURE_FAILED or OUTPUT_TOO_LARGE; null on success.
- `error` (string): Plain-English error message; null on success.

## Input settings

- `urls` (array, required): Public web pages to capture, one per line (up to 200 per run). "example.com" is read as https://example.com. Pages behind a login, private or internal addresses are not captured.
- `format` (string): PNG gives a lossless image, JPEG a smaller image, PDF a printable document with selectable text.
- `fullPage` (boolean): Capture the whole scrollable page instead of only the visible screen. Ignored for PDF (a PDF always contains the whole page).
- `viewport` (string): Desktop 1920×1080, Laptop 1366×768, Tablet 768×1024 and Mobile 390×844 (tablet and mobile use a phone/tablet browser and 2× pixel density). Custom uses the width and height below.
- `viewportWidth` (integer): Viewport width when Device is "Custom size".
- `viewportHeight` (integer): Viewport height when Device is "Custom size".
- `deviceScaleFactor` (integer): 1 = normal, 2 = retina. Leave empty to use the device default (1 for desktop/laptop, 2 for tablet/mobile).
- `waitFor` (string): When to take the capture. "Page load" suits most sites; "Network idle" waits for late requests (up to 10 s, extra-wait add-on); "Element appears" waits for the CSS selector below.
- `waitForSelector` (string): Used when "Wait until" is "Element appears", e.g. #main or .product-grid. If it never appears, the row fails with SELECTOR_NOT_FOUND.
- `delayMs` (integer): Additional wait before the capture, for animations or slow widgets. Any value above 0 adds the extra-wait add-on ($0.006 per captured page).
- `navigationTimeoutSecs` (integer): How long to wait for the page to start loading before the row fails with NAVIGATION_TIMEOUT. Leave empty for automatic: 15 seconds until 3 pages are captured, then 30 seconds, and pages that missed the 15 seconds are tried again with 30.
- `scrollToLoadLazyContent` (boolean): Scroll through the page before a full-page screenshot so lazy-loaded images appear.
- `hideCookieBanners` (boolean): Reject cookie consent pop-ups automatically (opt-out) and hide remaining consent banners.
- `blockAds` (boolean): Block ads and tracking scripts using EasyList / uBlock Origin filter lists. Often makes pages load faster.
- `hideSelectors` (array): Extra elements to hide before the capture, e.g. chat widgets or sticky headers: #intercom-container, .newsletter-popup.
- `maxFullPageHeight` (integer): Very long pages are cut at this height (the row gets truncated: true). Images are also limited to 16,000 device pixels, i.e. 8,000 px at 2× density.
- `jpegQuality` (integer): 1–100, used only for JPEG.
- `pdfFormat` (string): Paper size for PDF output.
- `pdfLandscape` (boolean): Landscape page orientation for PDF.
- `pdfPrintBackground` (boolean): Include background colours and images in the PDF.
- `pdfUseScreenMedia` (boolean): Render the PDF with the on-screen styles instead of the site's print styles.
- `proxyConfiguration` (object): Optional. Use Apify Proxy (for example a country) when a site shows a different page by location or blocks data-center IPs.

## Step by step on Apify

1. Open the Input tab.
2. In Website URLs (`urls`), keep the prefilled `https://apify.com` and `https://example.com`, or paste your own URLs, one per line.
3. Keep Output format = `png` and Full page on.
4. Click Start.
5. Open the Output tab. The Captures view shows a preview of each screenshot. Click `fileUrl` to open or download the file.

## Use cases

| Task | Input | You get | Key fields | Next step |
|---|---|---|---|---|
| Archive landing pages every week | `urls`, `format: "png"` | 1 PNG per page | `fileUrl`, `takenAt`, `title` | Schedule + webhook, save files to your storage |
| Check a page on phones | `viewport: "mobile"` | 780 px wide PNG (390 px × 2) | `fileUrl`, `width`, `height` | Compare with the `desktop` run |
| Save articles as PDF | `format: "pdf"`, `pdfFormat` | 1 PDF per page | `pdfUrl`, `pdfPages`, `bytes` | Store with your documents |
| Lighter files for many pages | `format: "jpeg"`, `jpegQuality` | 1 JPEG per page | `fileUrl`, `bytes` | Thumbnails, reports |
| Give an AI agent a "look" at a page | `urls`, `fullPage: false` | 1 screen-sized PNG | `screenshotUrl`, `title`, `statusCode` | Pass the link to a vision model |

## Tips

- Keep the default wait settings. Extra waits cost a little more per page.
- For 200 URLs, set the run timeout to about 35 minutes.
- If you used apify/screenshot-url before, you can keep your old input fields.

## Limits



- Up to 200 URLs per run. Larger lists: split them into several runs.
- About 7–8 full-page screenshots per minute at 4 GB (200 real sites took 26 minutes). 4 GB is the maximum memory; for 200 URLs set the run timeout to about 35 minutes.
- Each page has its own time limit (page load timeout + about 1 minute), so one slow site cannot block the run.
- If at least 3 pages time out or never show `waitForSelector`, and they are more than a third of the captured pages, the run stops with `stopReason: "TOO_MANY_TIMEOUTS"` so a list of dead sites or a wrong selector does not run for hours.
- In the same way, 10 or more failed pages of any kind (for example refused connections), when they are more than a third of the captured pages, stop the run with `stopReason: "TOO_MANY_FAILURES"`. Invalid URLs and unknown domains do not count: they never open a browser.

## Sample result

```json
{
  "url": "https://apify.com",
  "finalUrl": "https://apify.com/",
  "status": "success",
  "statusCode": 200,
  "format": "png",
  "fileUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/capture-0001-apify.com.png?signature=<signature>",
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/capture-0001-apify.com.png?signature=<signature>",
  "pdfUrl": null,
  "kvsKey": "capture-0001-apify.com.png",
  "contentType": "image/png",
  "bytes": 1034646,
  "width": 1920,
  "height": 10052,
  "pageHeight": 10052,
  "truncated": false,
  "pdfPages": null,
  "title": "Apify: Marketplace of ready-to-run tools for AI",
  "viewport": "desktop",
  "viewportWidth": 1920,
  "viewportHeight": 1080,
  "deviceScaleFactor": 1,
  "fullPage": true,
  "cookieBanner": { "detected": false, "cmp": null, "handled": false },
  "warnings": [],
  "loadTimeMs": 6638,
  "takenAt": "2026-10-13T12:30:04.076Z",
  "errorCode": null,
  "error": null
}
```

## Use it from code

Actor ID: `cliqtomedia/website-screenshot-pdf`

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("cliqtomedia/website-screenshot-pdf").call(run_input={
    "urls": [
        "https://apify.com",
        "https://example.com"
    ],
    "format": "png"
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

```bash
curl -X POST "https://api.apify.com/v2/acts/cliqtomedia~website-screenshot-pdf/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://apify.com", "https://example.com"], "format": "png"}'
```

```python
# pip install langchain-apify
# set APIFY_TOKEN in your environment
from langchain_apify import ApifyActorsTool

tool = ApifyActorsTool("cliqtomedia/website-screenshot-pdf")
result = tool.invoke({"run_input": {"urls": ["https://apify.com", "https://example.com"], "format": "png"}})
print(result)
```

run-sync waits up to 300 seconds; for longer runs start a run and use a webhook. LlamaIndex and MCP: https://cliqtomedia.com/actors/ai-agents/

## Similar tools

- [RSS & Atom Feed Reader / Monitor](https://cliqtomedia.com/actors/rss-atom-feed-reader-monitor/)
- [WordPress Posts & Pages Scraper](https://cliqtomedia.com/actors/wordpress-posts-pages-scraper/)
- [News Article Extractor: RSS, URLs & Clean Text](https://cliqtomedia.com/actors/news-article-extractor/)
- [PDF & Image to Text OCR for AI Agents - No Login](https://cliqtomedia.com/actors/pdf-text-ocr/)
- [RAG Web Search: Google Results as Clean Markdown](https://cliqtomedia.com/actors/rag-web-search/)
- [Website to Markdown for RAG: Crawl & Changed Pages](https://cliqtomedia.com/actors/website-to-markdown/)