Chrome can already take a full page screenshot without installing anything, and almost nobody mentions it. The command is three keystrokes away and it has been there for years. It is also wrong often enough that most people who try it once go looking for a tool instead — usually without understanding why it failed. This is what the built-in method does, exactly where it breaks, and what each of the alternatives actually fixes.
The command Chrome ships with
To capture entire webpage content this way, open the page, press F12 to open DevTools, then press Ctrl+Shift+P (Cmd+Shift+P on a Mac). A command box appears. Type "screenshot" and pick Capture full size screenshot. Chrome renders the whole document, including everything below the fold, and saves a PNG through your normal downloads.
No installation, no account, no upload. For a plain article or a documentation page this is the correct answer and the rest of this page is unnecessary.
The reason it has a reputation for not working is that it fails silently. You get a file, the file looks like a screenshot, and the broken parts are halfway down where you do not look.
The three ways the built-in capture goes wrong
These are worth knowing whichever method you end up using, because two of the three affect every tool.
Lazy-loaded images come out blank. Modern pages do not load images until you scroll near them. DevTools renders the full document without scrolling through it, so images that were waiting for a scroll event never load — you get grey boxes where the photos should be. The fix is manual: scroll slowly to the bottom of the page, wait for everything to appear, scroll back to the top, and only then run the capture.
Sticky headers repeat down the page. A navigation bar pinned to the top of the viewport is pinned relative to the screen, not the document. When the capture stitches the page together, that bar can appear again and again at regular intervals, slicing through the content behind it. Nothing in DevTools turns sticky positioning off for the duration of a capture.
Scrollable boxes inside the page are captured as they sit. If part of your page is a panel with its own scrollbar — a code block, a long table, a chat window — the capture takes whatever is currently visible inside that panel and nothing else. The page is long; the box inside it is not.
Four ways to capture a whole page
1. The DevTools command
Free, built in, nothing to trust. It produces a true entire page screenshot rather than a stitched approximation, which is why it gets the geometry right even when it gets the content wrong. Limited by the three problems above, and it gives you a raw PNG with no way to crop, annotate or redact afterwards.
Worth knowing: on very long pages it will quietly truncate rather than split the image, because PNG has practical size limits that a 40,000-pixel page runs into. You do get a file. It just is not the whole page.
2. Taking normal screenshots and stitching them
Screenshot the viewport, scroll, screenshot again, repeat, then line them up in an image editor.
Nobody should do this for a long page, but it is the only method that works everywhere — any browser, any operating system, a phone, a locked-down work laptop. It also handles sticky headers correctly, because you can crop the repeat out of each slice by hand. The cost is your afternoon.
3. Online services you paste a URL into
You give a web address, their server loads the page and sends back an image.
The limitation is structural rather than technical: their server is not signed in as you. Anything behind a login, anything in a dashboard, anything personalised, and anything on an internal network is invisible to them. They see the logged-out public version of the page or an error.
There is also a privacy consideration people skip. You are telling a third party which page you wanted a picture of, and for an internal or client URL that may be more than you intended to share.
4. A browser extension
An extension runs inside the tab you are looking at, so it sees the page exactly as you do — logged in, personalised, behind whatever authentication you already passed.
The useful ones also do the two things DevTools does not: they scroll the page first so lazy images load, and they suppress sticky positioning while the capture runs so the header appears once. That is the actual difference between a usable full page screenshot chrome workflow and a PNG with grey rectangles in it.
Five questions that separate the tools
Mac, Windows and phones change less than you would think
The DevTools command is identical on Windows, macOS, Linux and ChromeOS — only the modifier key differs, Cmd instead of Ctrl. There is no Mac-specific version of this and no Windows-specific one.
Phones are the real break. Chrome on Android and iOS has no DevTools and no extensions, so the browser itself cannot do it. iOS has a partial answer inside Safari: take a normal screenshot on a web page, tap the preview, and choose Full Page, which saves a PDF of the whole document rather than an image. Android has no equivalent that works across all pages; some phone makers add a "scroll capture" to the system screenshot tool, and it stitches visually rather than rendering the document, with all the sticky-header problems that implies.
If you are on a phone and the page matters, the honest answer is to open it on a computer.
Checking a capture before you send it
Three seconds of checking saves resending it later. Scroll through the image and look for grey or blank rectangles where photos should be — that is the lazy-loading failure. Look for your navigation bar appearing more than once — that is the sticky failure. Then check the very bottom of the image is the actual bottom of the page, because truncation looks exactly like a page that happened to end there.
If you are capturing something you will keep — a receipt, an invoice, a confirmation, a conversation — do this check every time. Those are precisely the pages you cannot go back and re-capture later.
Picking a tool you will still be using next month
If you decide on the fourth route, the market is crowded and the listings all claim the same things. Three checks separate them quickly, and none of them requires installing anything first.
Read the permissions on the store listing before you install. A screenshot chrome extension needs to read the page it is capturing, which is a broad permission by nature — but it does not need your browsing history, your bookmarks, or access to sites you are not capturing. Anything asking for more than it needs is telling you what the product really is.
Then check where the image goes. A capture that uploads to the developer's server before you see it means every page you screenshot — including logged-in dashboards and client work — passes through someone else's infrastructure. Local capture is both faster and the only version you can use on anything confidential.
Finally, test it on a page with a sticky header and lazy-loaded images, because that is where tools differ and where listings are silent. A product page on a large retailer is a good test: long, image-heavy, and almost always has a pinned navigation bar. If a tool survives that page, it will survive yours.
Capturing from inside the tab you already have open
If the fourth method sounds right, this is what it looks like in practice. InkShot runs in the page you are on, so it captures logged-in and personalised views that a URL-based service cannot reach.
It scrolls the document first so lazy-loaded images are present, and it handles sticky elements so the header appears once rather than repeating down the image. You can draw on the result straight away — arrows, boxes, highlights, blurring over anything you do not want to share — and save or copy it without a separate editor. It also captures a selected region or just the visible area when you do not need the whole page.
Frequently Asked Questions
Which method fits what you are doing
A one-off capture of a public article: use the DevTools command, scroll the page first, done in ten seconds.
A page behind a login, or one you need to annotate before sending: that rules out URL-based services immediately, and leaves the DevTools command plus an image editor, or an extension that does both in one pass.
Capturing pages regularly — bug reports, client work, documentation, receipts: the per-capture friction is what matters, and the scrolling-and-sticky handling stops being a nice detail and becomes the whole job.
Whichever you use, the habit worth building is the same: scroll the page to the bottom before you capture anything, and look at the result before you send it. Both failures are silent, and both are obvious once you know to look.