# Page Scanner > Page Scanner captures a whole web page in the user's own Chrome and writes a PDF whose text stays text, a PNG or JPEG, or Markdown. A Chrome extension does the capture; a command line (`@page-scanner/cli`) and an MCP server (`@page-scanner/mcp`) let an agent drive it on the same machine. To use it from an agent: the user installs the extension from the Chrome Web Store, then either register the MCP server (`npx -y @page-scanner/mcp serve`) or run the command (`npx @page-scanner/cli`). `install` sets up the helper Chrome starts, and the user presses Connect in the extension's settings once per profile; an agent cannot. Every page below is also plain Markdown at its address with `.md` added. The product's site is https://pagescanner.app. --- # Introduction Page Scanner captures a whole web page and keeps its text as text. Page Scanner captures a web page from the top to the bottom of its scroll, lets you crop the part worth keeping, and exports it as a PDF whose text you can still select and search, as a PNG or a JPEG, or as the crop's text in Markdown or Word. It can also open a PDF or a picture from your disk in the same editor, to crop, mark up and redact it. It lays the page out once at its full height and asks Chrome to print it, so the preview you crop and the PDF you keep come from the same layout. It all happens in your own browser, and no capture or file is uploaded. ## Five ways to use it **[The web extension](https://docs.pagescanner.app/extension)** is the product. Click its icon on a page and press Scan, crop the capture in the editor, and export it. **[The command line](https://docs.pagescanner.app/cli)** captures a page from a script or a terminal, through the Chrome you are already signed in to. **[The MCP server](https://docs.pagescanner.app/mcp)** lets an AI agent on your own machine do the same. **[The Obsidian plugin](https://docs.pagescanner.app/obsidian)** saves a tab into your vault as a PDF and a Markdown note. **[The Raycast extension](https://docs.pagescanner.app/raycast)** scans the tab in front of your browser from Raycast. The command line, the MCP server, the Obsidian plugin and the Raycast extension all work by asking the extension for the capture, so all four need it installed. [Local agents](https://docs.pagescanner.app/extension/local-agents) explains how they connect to it. ## Let an agent set it up An AI agent on your computer can install the MCP server, register it with itself and set up the connection to Chrome, and then ask you for the two steps that happen in Chrome. Copy this into it. The [command line's install page](https://docs.pagescanner.app/cli/install) has the same for the command on its own. ```text Set up the Page Scanner MCP server for yourself, so you can capture web pages through my Chrome. The install guide is https://docs.pagescanner.app/mcp/install.md and connecting Chrome is https://docs.pagescanner.app/mcp/pairing.md; every page of the documentation at https://docs.pagescanner.app is also Markdown at its address plus .md. 1. Run `node --version`. Page Scanner needs Node.js 24 or newer; if it is older or missing, stop and tell me. 2. Register the server with the client you are running in: - Claude Code: run `claude plugin marketplace add sbd530/page-scanner-skills`, then `claude plugin install page-scanner@page-scanner-skills`. The plugin registers the server and adds the agent skill. - VS Code: run `code --add-mcp '{"name":"page-scanner","command":"npx","args":["-y","@page-scanner/mcp","serve"]}'`. - Cursor: add `"page-scanner": {"command":"npx","args":["-y","@page-scanner/mcp","serve"]}` under mcpServers in `~/.cursor/mcp.json`. - Any other client: add the same entry under the key it reads its servers from. If you do not know which file that is, ask me. Outside Claude Code, also run `npx skills add sbd530/page-scanner-skills`, the agent skill that teaches you when and how to use the tools. 3. Run `npx @page-scanner/mcp install`. It sets up the helper Chrome starts to reach Page Scanner, for every Chromium browser on this computer, and prints which. It returns no secret. 4. Then ask me to do the part only I can do, in Chrome, and wait until I say it is done: - install the Page Scanner extension if I have not, from https://chromewebstore.google.com/detail/page-scanner/oinkohacnbkapdnnhpidmoidmidlgaoj?utm_source=docs.pagescanner.app (or https://microsoftedge.microsoft.com/addons/detail/edlmbcahnbpdfibbimdkdbgiemadanhh?utm_source=docs.pagescanner.app in Edge); - open its settings, and under Local Agents give this browser a name, press Connect and allow Chrome's prompt. 5. Run `npx @page-scanner/cli browsers` to check. The first connection can take up to a minute, so if nothing is listed, wait and run it again before you tell me it failed. Do not call the pair tool or run `npx @page-scanner/mcp pair` unless I ask for it: it puts a pairing token into this conversation, and the helper needs none. When it works, tell me which browsers are connected, and whether I have to restart you, or start a new session, before the server's tools appear. ``` --- # Getting started Install the extension and capture your first page. ## Install Add Page Scanner from the [Chrome Web Store](https://chromewebstore.google.com/detail/page-scanner/oinkohacnbkapdnnhpidmoidmidlgaoj?utm_source=docs.pagescanner.app), or in Microsoft Edge from the Edge store, [Edge Add-ons](https://microsoftedge.microsoft.com/addons/detail/edlmbcahnbpdfibbimdkdbgiemadanhh?utm_source=docs.pagescanner.app). It is the same extension in both, and it runs in Google Chrome, Microsoft Edge and other Chromium browsers. The install opens a welcome page. Chrome and Edge put a new extension in the Extensions menu, the puzzle piece beside the address bar, so the page says how to pin the icon to the toolbar (Chrome's pin, Edge's "Show in toolbar") and shows the shortcut your browser assigned. If another extension already uses `Alt+Shift+P`, the browser leaves it unassigned, and the page offers **Set a shortcut**. **Try it on the guide** opens this page, to try the first scan on. ## Capture a page Open the page you want and click the Page Scanner icon in the toolbar, or press `Alt+Shift+P`. A small panel opens with one choice on it, **Page width**, and a **Scan this page** button. The button is already focused, so pressing `Enter` starts the scan. Point at the question mark beside **Page width** to read what the chosen width does. The editor opens on the capture. The first time, a short tour points out the crop, the tools, the output and **Extract**; it can be shown again from the [settings](https://docs.pagescanner.app/extension/settings#tour-of-the-editor). ## Capture one element To capture a single table, chart or card, press **Pick an element** below the **Or** under the Scan button, or `Alt+Shift+E` on the page itself. A green outline follows your pointer and shows the element's size. Press `↑` to take in its parent instead, which is how you get a whole table from inside one of its cells, and `↓` to go back; click or press `Enter` to capture, `Esc` to cancel. The whole page is captured as usual, and the editor opens with the crop exactly on what you picked, so everything else works the same. An element inside a box that scrolls on its own is captured only as far as that box shows it, and the editor tells you when that happened. ## Map a whole site **Map this site**, under **Pick an element**, captures up to 30 pages of the site you are on and draws them as a flow, joined by the links between them. It asks for access to that one site first and shows you the list of pages before it captures any. [Map a site](https://docs.pagescanner.app/extension/site-map) walks through it. ## Record the steps of a task **Record steps**, under **Map this site**, makes a guide of a task you click through once: a picture and a sentence for each click that changes the screen, with sign-in and ID fields covered, saved as one PDF. [Record steps](https://docs.pagescanner.app/extension/record-steps) walks through it. ## Scan how a page scrolls **Scan scrolling**, under **Record steps**, scrolls the page by itself and makes a storyboard of it: the page cut into scenes, six frames each, with what moved said in words and how it feels when the scroll stops, saved as one PDF to hand to an AI coding agent instead of a video. [Scan scrolling](https://docs.pagescanner.app/extension/scroll-storyboard) walks through it. ## Capture several tabs into one file Select the tabs first, the way Chrome selects tabs: `Cmd`-click (`Ctrl`-click on Windows and Linux) each tab's strip, or `Shift`-click to take a run of them. Then click the icon. The panel says how many are selected and the button becomes **Scan 3 tabs**. Each tab is captured in turn, and the badge counts them. The editor opens on one capture holding every tab, top to bottom in tab order, each under a band with its page title. A PDF gives each tab pages of its own, with a bookmark named after it, and with the stamp on, each tab's pages carry that tab's own address. An image export is all of them in one picture. It takes two to ten tabs from one window. If one of them cannot be scanned, a `chrome://` page for instance, the panel's scan stops and the page tells you which tab it was, so you can leave it out and try again. Picking one element is not offered with several tabs. ### A file per tab, for research In the **Output Format** panel, a capture of several tabs has a **Tabs** group. **A file per tab, in a ZIP** makes Extract write one ZIP instead of one document. Inside it: - each tab as a file of its own in the format you chose, with its text beside it as Markdown, and each cited as that tab's page declares; - `references.ris`, a reference per tab for a reference manager, pointing at its file; - `index.md`, which lists the tabs with their addresses and each file's SHA-256; - `SHA256SUMS`, so `shasum -a 256 -c SHA256SUMS` in the unzipped folder says whether any file changed since. A tab your crop leaves out is left out of the ZIP. Your marks and every other choice in the panels apply to each file as they would to the one document. ## Page width This is the one thing that has to be decided before the scan, because the capture lays the page out once and everything after that comes from the same layout. - **The window, as it is** is the default and is what you see on screen. On A4 or US Letter the capture is then scaled down to fit between the margins: a 1280 px window comes out at 55 %, which puts ordinary 16 px body text at 6.5 pt. - **Narrowed to A4** lays the page out 698 px wide first, the way it would look if you dragged your window narrow. It then fits A4 with no scaling at all, and the same body text comes out at 12 pt. **Narrowed to US Letter** does the same at 720 px. - **Narrowed to a phone** lays the page out 390 px wide, as a phone's screen shows it, so a responsive site shows its mobile layout. For a PDF, **Phone screen pages** in the export then cuts it into phone-sized pages at 100 %. Narrowing only works as far as the page's own CSS allows. A page built around a fixed-width table stays as wide as that table, and the size under the page's title, in the editor's top-left corner, tells you what width you actually got. The choice is remembered, so the next scan is the icon and `Enter`. Everything else a scan can be told is in the [settings](https://docs.pagescanner.app/extension/settings), behind the gear in the panel. ## Say how to scan, in the side panel The button left of the gear, with the Assistant's icon, opens the browser's side panel beside the page. Say there how this page should be captured, in a sentence, in any language: "A4 width, without ads or cookie banners", "다크 모드로", "折りたたみを全部開いて". The two examples in the empty conversation are a start: a click sends one. The model of the editor's [Assistant](https://docs.pagescanner.app/extension/editor#tell-the-editor-what-to-do), on Page Scanner's server, reads it and sets what the scan decides before it starts: the width, the clutter hidden first and what is kept, folded sections, the color scheme, videos, and whether you pick one element first. Where the request needs it ("make it clean for printing"), the Assistant looks at the page first: it counts the ads, cookie banners, chat widgets and pop-ups the scan would hide, and sees whether the page has a dark version, how large it is and how many sections are folded. It gets those counts, never the page's text. Nothing on the page changes while it looks. It then says in a sentence what the scan will do, and what it set waits above the box, headed "Scan with these choices?". Press **Scan** (`⌘/Ctrl` + `Enter`) to scan with it, or **Reject** (`Esc` in the empty box). A second request while it waits adds to it: "and in dark mode" after "A4" keeps the A4. Nothing is scanned until you press **Scan**, whatever the sentence says; with one element in the plan, the button reads **Pick, then scan**. A request for what the editor decides after the scan, such as the format, the stamp or hiding sensitive text, gets an answer that the editor does it, and nothing is set. The editor then opens as usual, with its Assistant up and your conversation in it, so you can go on telling it what to do with the capture. The side panel closes as the editor opens. What you say holds for this scan only; the settings stay as they were. Every message is read by Page Scanner's server, which is sent the conversation, the scan's choices and the counts above. The panel shares the Assistant's 10 messages a month, its 8 steps a message and its switch in [Settings › AI Model](https://docs.pagescanner.app/extension/settings#page-scanners-server). With that switch off, or the panel opened any other way than from the popup, it says so in its middle and takes no request. The panel scans the tab it was opened for. The button is not there over the editor, which has its own Assistant, or for several selected tabs. It is a preview, badged **Preview**. The panel takes its width from the window, so **The window, as it is** lays the page out at the width left beside the panel. Choose A4 or Letter there, or close the panel and scan from the popup, for the page at the window's full width. ## Open a picture instead of a page The third button in the panel, **Open a PDF or image**, opens an empty editor beside the tab. Drop a PDF, a PNG, a JPEG or a WebP on it, paste a picture from the clipboard, or press **Choose a file**, and the editor opens it as if it were a capture: crop it, mark it up, look for sensitive text and redact it, and export it as a PDF, a PNG or a JPEG. The file is read in that tab and is not uploaded anywhere. A PDF's pages are laid one under the other on a gray sheet, and its text stays text. It opens on **Single long page**, which writes its pages back out as they were, each at its own size, a landscape page landscape. What you typed into a PDF form stays; comments, highlights a reader drew and links do not come across. A password-protected PDF cannot be opened: open it in Chrome, print it to a new PDF, and open that. A very long PDF opens on as many pages as fit, about 51 A4 pages, and the pages after those are left out without a note in the editor. The picture's size comes from the resolution written into it. A Retina screenshot, which says 144 dpi, opens at half its pixel size, the size it was on screen; a 300 dpi scan of an A4 page opens A4 wide. A picture that says nothing opens a pixel to a CSS pixel. A picture has no text of its own, so its PDF holds an image. A scanned PDF is the same: its text is a picture of text. Markdown and Word are not offered for any file opened this way, a PDF with real text included, since there is no page structure to write, and the stamp shows only the time the file was opened, since there is no address. Only a PDF, a PNG, a JPEG or a WebP opens; a GIF, a HEIC and anything else is refused by name. A picture can be at most 32,767 pixels on a side and 90 million pixels in all. Over an editor holding an opened file, the panel offers **Open a PDF or image** again rather than a rescan. ## Scanning the same page again A scan leaves the editor tab in front, so pressing the icon again lands on the editor rather than on the page. The panel notices and offers the page that editor came from: it reads **Again** followed by the page's title, and the button becomes **Scan it again**. That is how you take the same page at a different width without hunting for the tab. If you have closed that tab or moved it somewhere else in the meantime, the panel says so instead of scanning something you did not mean. ## While it runs The panel stays open while the scan runs: its choices give way to a large green scanning animation over the line **Scanning this page.** The icon's badge follows the scan while it measures the page, lets it settle, captures it and builds the PDF, and keeps following it if you click away, which closes the panel without stopping the scan. If the scan fails, the panel comes back with the reason. When it finishes, an editor tab opens right next to the page you scanned, holding the whole page from the top of its scroll to the bottom. Before the capture, ads, cookie and consent banners, chat widgets and pop-ups are hidden, and put back on the page afterwards. When anything was hidden, the editor says what in a toast, with a **Capture settings** button (unless that notification is off in the settings). Turn the switches off in [the settings](https://docs.pagescanner.app/extension/settings) when you want the page exactly as it looked. While a scan runs, Chrome shows a bar that reads "Page Scanner: Full Page Screenshot" started debugging this browser. That is Chrome's own notice for any extension using its debugger. Chrome takes it down five seconds after the scan lets go of the page, which is why it is often still up as the editor opens, and no extension can hide it or take it down sooner. The editor says as much in a small card by its toolbar while the bar is up, and the card goes with the bar. [Why the debugger](https://docs.pagescanner.app/extension/debugger) explains what it is used for. One scan runs at a time per tab. A second request while one is running is ignored. ## Vector or raster A raster capture is not labeled in the editor; the **PDF** option in the Output Format panel says that its PDF holds an image. A vector capture needs no note. - **Vector** is the normal case. The PDF holds real text you can select, search and copy, and artwork that stays sharp at any zoom. - **Raster** is the fallback when Chrome's debugger cannot attach to the tab, most often because DevTools is already open on it. The page is scrolled a screen at a time and the pieces are stitched together, so the PDF holds an image. Close DevTools and scan again to get a vector capture. ## What it can touch It asks for no host permissions. It reaches a page only when you click the icon or press the shortcut on it, when you select several tabs and scan them together, or when a script or agent you connected asks it to. Connecting asks for two optional permissions, to talk to Page Scanner's helper and to manage tab groups; see [Local agents](https://docs.pagescanner.app/extension/local-agents). A capture is kept in the extension's own storage inside your browser, and is deleted the next time the extension starts if it is more than 12 hours old. There is no account, and no capture, mark or exported file is uploaded. Page Scanner's server reads what you say to the Assistant and the side panel, with their choices and counts, and never sees the page. The extension does send anonymous usage statistics, which features were used and never which page, and [Settings](https://docs.pagescanner.app/extension/settings#report-usage-statistics) turns them off. The privacy policy, linked at the top of the sidebar, has the details. ## Next - [Crop, zoom and pan](https://docs.pagescanner.app/extension/editor) in the editor. - [Export](https://docs.pagescanner.app/extension/export) a PDF, a PNG or a JPEG. --- # Crop, mark up, zoom and pan Keep the part of the page worth keeping, draw on it, and move around a capture that may be thousands of pixels tall. The editor is laid out like a design tool's canvas. The capture fills the stage, and a few controls float over it: in the top-left corner, what you scanned (the site's icon and the page's title, cut short past 25 characters, with the whole title when you point at it); at the top center of the canvas, the toolbar; in the bottom-left corner, the zoom. The panels that decide what the file looks like open from a rail at the right edge. The panel starts folded, so the page gets the whole width; click an icon on the rail, or the expand button at its head, to open one, or press `⌘/Ctrl` and the panel's number: `1` is Output Format, `7` is the Assistant. Hold `⌘/Ctrl` for a moment to see each button's key badged on it. The toolbar stays centered over the canvas, so it moves over when the panel opens or folds. ## Crop The capture opens with the crop on the whole page and the crop tool active. Drag the frame's edges or corners to resize it, and drag inside it to move it. **Crop to the main content** on the toolbar puts it on the page's article or column of text, past the site's header, its sidebars and its footer, and the button is off while the crop is on it. **Reset crop**, beside it, or `Esc`, puts it back on the whole page. To place something in the frame by eye, the **Frame** panel's last group, **Guides**, draws lines inside the crop: the rule of thirds, the golden ratio, center lines, quarters or the two diagonals. They are off until you switch them on, stay as you left them for the next capture, and are never in the file. The main content is found while the page is scanned, from the page's own markup (its `main` and `article`) and, where the markup says nothing, from where the paragraphs of real text are. A page with no one column, such as a front page or a search result, has none, and the button is off. A page that sets its text beside a sidebar, as a GitHub issue or a forum topic does, opens on the column of posts and comments without the sidebar. On a news site the crop can run on past the story into the recommendations below it; drag the bottom edge up. [Settings](https://docs.pagescanner.app/extension/settings) can make every capture open on the main content. The crop is exact rather than approximate. The preview you drag over and the PDF are taken from the same layout of the page, so the frame lands on the file exactly where you drew it. On a Retina screen the bottom of a very long page can be a few pixels off; [the FAQ](https://docs.pagescanner.app/faq#why-does-the-bottom-of-a-long-page-sit-a-few-pixels-off) says why. ## Mark up the capture The toolbar at the top of the editor holds the tools, in groups. Each group is one button showing the tool you last used from it, with a small arrow beside it that lists the rest of the group: | Group | Tools | | ---------------------- | ----------------------------------------------------------------------- | | Crop and cut | **Crop** (`C`), **Cut a band out** (`K`) | | Select and remove | **Select** (`V`), **Remove element** (`D`) | | Shapes | **Rectangle** (`R`), **Ellipse** (`O`), **Line** (`L`), **Arrow** (`A`) | | Highlight and close-up | **Highlighter** (`H`), **Magnifier** (`M`) | | Text, steps and emoji | **Text** (`T`), **Step number** (`N`), **Emoji** (`E`) | | Hide text | **Blur** (`B`), **Redact** (`X`), **Erase text** (`W`) | The tool in use is filled green. A tool's key picks it from any group. After the tools come undo and redo, then the two crop buttons, and **Extract** at the right end. **Remove element** takes something out of the page itself: a banner, a sidebar, a card in the middle of an article. Point at it and the label beside the pointer names it; `↑` picks the box around it, `↓` goes back in, and `←` and `→` step to the box before or after it. Click to mark it (as many as you like), then press **Remove 1 element** (or **Remove 3 elements**, by how many you marked) at the bottom of the stage. The page is scanned again without it, so what was below moves up to close the gap. The tab you scanned has to still be open on the same page, and the new capture starts without your crop and marks. **Put back** scans it again with everything in. Pick a shape and drag on the capture to draw it. Hold `Shift` to keep a square, a circle, or a line on a multiple of 45°. As soon as you let go the new mark is selected and the tool goes back to **Select**, so you can adjust it at once: drag it to move it, drag a handle to resize a box or move the end of a line, press `Delete` to remove it. Click on nothing to deselect; drag on nothing to pan. While a mark tool is in use or a mark is selected, a second bar appears under the toolbar: eight colors and a picker for any other, four stroke widths, **Fill** for a rectangle or an ellipse (a translucent tint of the stroke color), **Rounded** for a rectangle, **Both ends** for an arrow. With **Remember the last choices** on in [Settings](https://docs.pagescanner.app/extension/settings), the bar keeps what you last chose, so the next capture's first mark is drawn the same way; it is off at first. A change restyles the selected mark and becomes what the next mark is drawn with. **Text** is written in place. Press `T`, click where the words go (or drag to set the width), and type. The words wrap inside the box, whose height follows them; click elsewhere or press `Escape` when you are done, and double-click the words to change them later. The bar offers the color, five sizes, three faces (Sans, Serif and Mono), bold, italic, and a box behind the words in a color of your choosing, for text over a busy page. In the PDF the words are text: you can select and search them. They are set in the PDF's own standard fonts, which cover Latin script and a few extras but not Korean, Japanese or Chinese. Words in those scripts go into the PDF as a picture, drawn in your computer's font the way you see them on the stage, with the words laid over the picture invisibly, so you can still select, search and copy them. The box says so as you type. On a page in Korean, Japanese or Chinese there is a better way. The **Page** list in the bar holds the fonts the page itself is set in. Pick one and your words are drawn in the page's own font, and in the PDF they are real text in that font. The page only carries the characters it shows, so if you type one it never used, the box names it and the words go in as a picture again. Bold and italic come with the font, so those two buttons are off while one is chosen. The highlighter has four pens. Drag across a passage and it is covered in a band of color that darkens the page and leaves the text at full contrast, the way a real one does; hold `Shift` to keep the band straight and one line tall. Two passes of one color look like one. The text under a band is still text in the PDF. **Start the drag on a word and the selection follows the text**, line by line, like selecting text in a browser: the highlighter, the blur, the redaction and the erase all do this, and the pointer shows the text cursor over the words. Start the drag beside the text, or hold `Alt`, for a free box instead. A capture that fell back to raster, or a picture you opened, has no text to follow until the **Sensitive Text** panel has read it; after that the drag follows the words it read. **Emoji** are stamped. Press `E` and the bar becomes a picker: type a word (`thumbs`, `fire`, `check`) to narrow the grid, click the one you want, then click on the capture to place it. A click stamps it at a fixed size; a drag sets the size. Once placed, drag it to move it, drag a corner to resize it, and pick another emoji in the bar to swap it. The emoji is drawn by your computer's own emoji font, and it goes into the PDF as a picture rather than as text, so it looks the way your system draws it and cannot be searched for. **Step numbers** put 1, 2, 3 on the page for a how-to or a bug report. Press `N` and click where each step is; the tool stays in hand, so each click places the next number. A drag sets a badge's size. The number is the badge's place in the order you placed them, so deleting one renumbers the rest. The bar offers the color, and the number is white or black, whichever reads on it. **The magnifier** shows a small detail larger. Press `M` and drag round the detail: the region gets an outline, and a copy at twice its size appears beside it, joined by a line. Drag the copy to move it, drag its corners to resize it (it keeps the region's shape), and drag the region's outline to look at another spot. The copy includes the marks under the region, so a blurred, redacted or erased detail stays hidden in it, even if you hide it after making the copy. The copy is a picture of the region, in a PDF as in a PNG, so it is as sharp as the capture and its words cannot be selected; the words on the page beside it still can. **Cut a band out** (`K`) takes a stretch of the page out of the file and closes the gap: the ad between two paragraphs, the newsletter box in the middle of an article. Drag down across it; the band always runs the full width of the page. On the stage it is hatched and the page stays where it is, but the Output Format panel counts the pages and pixels without it, and in the PDF and the image what is below the band moves up to meet what is above. Its words are not in the PDF at all. Drag its top or bottom edge to adjust it, or delete it to put the band back. **Sensitive Text**, the shield below the other icons on the editor's right edge, opens a panel that looks through the crop's text for what should not be shared. It looks for nothing until you press one of its scans, each a magnifier on the right of its title, and each as often as you like: - **AI Scan** looks for what no rule can: tick **Names** (people's names, and user names and handles), **Postal addresses**, **ID numbers** (national ID and resident registration numbers, social security numbers, passport and driver's licence numbers, tax and business registration numbers) or **Payment details** (bank account and routing numbers, card expiry dates and security codes, and card or account numbers the rules missed). It runs on Chrome's own built-in model, on your computer, and the text is not sent anywhere; or on a model you serve on this computer, or a small model Page Scanner downloads to run in the browser, chosen in [Settings › AI Model](https://docs.pagescanner.app/extension/settings#ai-model). Where there is no model to ask, the panel says why and the scan button stays disabled, and offers a small model to download from Hugging Face and run in the browser, with its size on the button. Once it is downloaded, AI Scan and tidying use it. Where the browser has no WebGPU, it points at a model you serve on this computer instead. - **Pattern Scan** looks for what has a known shape: tick **Email addresses**, **Phone numbers**, **Card numbers**, **IBANs**, **ID numbers**, **IP addresses** or **Keys and tokens**. The words and patterns you added in the [settings](https://docs.pagescanner.app/extension/settings#sensitive-text) are looked for with them. **ID numbers** checks the digits of Korea's resident and business registration numbers, Japan's My Number, China's resident ID, Italy's codice fiscale and partita IVA, and US Social Security numbers, on your computer. A number written as bare digits, and any My Number, is found only with its name just before it (주민등록번호, マイナンバー, SSN...), since order and tracking numbers look the same. - **Custom Pattern** takes a word or a `/pattern/` to find in this capture only; press its magnifier or Enter. The ticks of both scans are folded away at first; the arrow left of a scan's magnifier opens them. They are remembered for your next capture. Each run of a scan replaces its last run's finds, so a kind you untick is gone after the next run. Everything found is listed under **Finds**, masked, with the count in a badge beside the title, and outlined on the stage. The list shows about seven at a time and scrolls. Each find has an eye that brings it into view at 100 %, and a trash can that takes it off the list when it is not what it was taken for: it stays off for that capture, even if you scan again, and the **Undo** in the message brings it back. Untick what should stay. The checkbox on the right of **Finds** ticks or unticks them all: it shows a check when all are ticked and a dash when only some are. Under **Hide Them By** choose **Erase**, **Blur** or **Redact**, with the blur's strength or the redaction's color right there, and the button at the foot of the panel, **Redact 9** for instance, hides the rest in one step. They become ordinary marks, which you can still move or delete, and none of them is left selected. A find that is already under a blur, a redaction or an erase drops out of the list, so once they are hidden the panel says there is nothing left to hide; undo brings them back. The question mark beside the panel's title says what each way does to the PDF. A capture taken as an image, or a picture you opened, has no text of its own, so the panel reads it first, on your computer, with the same engine a searchable PDF uses, and shows how far along it is. Recognition can misread a word, and a misread word is not found, so look the crop over as well. Whichever way you hide a find there, it is painted over the picture in every export. On a scanned PDF the panel offers **Redact** only, and says why: a blur or an erase would leave the scan's pixels in the file, while a redaction turns that PDF into a picture with the box painted in. While AI Scan runs, a green spinner turns beside its line, which says what is going on and the time so far ("Scanning the crop with Chrome's model, 12 s so far."). The first time, Chrome downloads the model; once Chrome gives a figure the line gives its percent, and until then it says "It has not said how far along it is; 2 min so far". Chrome often gives no figure until the download is over, so a spinner that turns for minutes is a download still going, not a stuck one. **Blur**, **Redact** and **Erase text** hide what is under a box, and they are three tools because they promise three different things. Blur softens the pixels so a thing cannot be read; the bar offers five radii, and the stage shows the blur as it will come out. Redact paints the box solid, black unless you pick another color, and removes what is under it from the file. Erase text takes the words out as if you had deleted them and paints nothing: on the stage and in an image the box takes the color of the page around it, and in the PDF the page's own background shows where the words were. An erase always sits under your other marks, so an arrow or a highlight drawn over it stays visible. In a PNG or a JPEG the three are what they look like. In a PDF, read this before you rely on any of them. The PDF normally keeps the page's text as text, and a picture laid over text hides it from nobody who copies or searches the file. So under a **blur the PDF's text is rewritten**: each letter under the box becomes another letter of the same font, spaces stay, and what comes out of the file where the blur is reads like `xxxx xxxxx`. The blurred picture is laid over those. A photo, a chart or a drawing under a blur is only covered. Under a **redaction the PDF's text is removed** outright, and the rest of the page stays text. A redaction promises that nothing under it survives, and a photo cannot be cut out of the page, nor a drawing that runs past the box's edge: so a redaction over one makes the whole PDF a picture, with the box painted into it, and the price is that the text elsewhere on the page is no longer selectable. Under an **erase the PDF's text is removed** too, and nothing is drawn in its place. An erase promises only that the text is gone: a photo, a logo or a drawing under it stays in the file, in plain sight, and the rest of the page stays text. The hint on the Output Format panel's PDF option says which you will get before you extract, with the reason. If you need the rest of the page's text to stay text, crop the picture away first, or redact in a PNG. The marks go into every export. In a PDF they are vectors drawn over the page, and the page's text stays selectable around them; a mark that crosses a page break appears on both sheets, cut at the break. In a PNG or a JPEG they are drawn over the pixels. A mark outside the crop is not in the file; the stage draws it faintly there so you can bring it back. Marks are kept with the capture, so a reloaded editor tab still has them, and like the capture they never leave the browser. `⌘/Ctrl` + `Z` undoes and `⌘/Ctrl` + `Shift` + `Z` redoes. `Esc` backs out one step at a time: the selection, then the tool back to crop, then the crop back to the whole page. ## The stage's menu A right-click on the stage opens a menu of what the editor can do from there, each with its key: **Copy as PNG** (`⌘/Ctrl` + `C`, which copies the crop to the clipboard as a picture with its marks, whatever format the Output Format panel has), **Extract**, which writes the file at once, the crop (to the main content or the picked element, to what is on screen, or back to the whole page), undo and redo, deleting the selected mark, the tools, the zoom and the settings. ## Zoom and pan | Action | How | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------- | | Zoom in or out | `⌘/Ctrl` + `+` or `-`, pinch on a trackpad, `⌘/Ctrl` + scroll, or **−** and **+** in the bottom-left corner | | Fit to window | **Fit to window** in the zoom menu, or right-click the stage | | Actual size (100 %) | Right-click the stage | | Pan | Drag the background, or scroll with two fingers | | Back out | `Esc`: the find bar, the selection, the tool, then the crop | | Undo, redo | `⌘/Ctrl` + `Z`, `⌘/Ctrl` + `Shift` + `Z` | | Export | `⌘/Ctrl` + `P`, or **Extract** at the right end of the toolbar | | Open or close a panel | `⌘/Ctrl` + `1` to `7`, in the rail's order | | Fold the panel | `⌘/Ctrl` + `B`, or the button at the head of the rail | | Widen the panel | Drag its left edge, from 320 px to 416 px; or focus it and use the arrow keys; a double click goes back | | Settings | `⌘/Ctrl` + `,`, or the gear at the foot of the rail | | Find in the capture | `⌘/Ctrl` + `F` | | Ask the Assistant | `⌘/Ctrl` + `K` | **Actual size** also scrolls back to the top of the crop, just under the toolbar, so it still does something when you are already at 100 %. **Fit to window** shows the whole capture, however tall, with room left above it for the toolbar and below it for the zoom, so the crop's top edge never opens under the toolbar. Zoom goes from 2 % to 1,600 %, but a page too tall to fit at 2 % is fitted below it, 60,000 px at about 1 % on a laptop's screen, and zooming out stops there. The percentage in the bottom-left corner opens a menu of Fit to window and a few fixed sizes. ## Accessibility With **Check accessibility** on in the [settings](https://docs.pagescanner.app/extension/settings), the editor's rail has an **Accessibility** panel for the capture. It says how many WCAG rules the page failed and by how many elements, then lists each rule with its elements, numbered. The eye beside an element takes the view to it, and while the panel is open every failing element is boxed and numbered on the page, red for critical, orange for serious, blue for moderate and gray for minor. The boxes are only on screen; an export does not carry them. **Download marked PDF** saves the capture with the boxes drawn on and the rules listed after the page, to pass on. ## Find in the capture `⌘/Ctrl` + `F` opens the editor's own find bar at the top right of the window, where it stays when a panel opens. Chrome's find bar cannot read the capture, because the page is drawn as a picture, so the editor searches the capture's text itself. Type a word or a phrase: every place it appears is painted amber and the current one green, and the count says which of how many it is on. `Enter` goes to the next and `Shift` + `Enter` to the one before, and the stage moves to it, zooming to 100 % when the text is too small to read where you are. `Esc` closes the bar. The whole page is searched, whatever its case, and a phrase is found where it wraps from one line to the next. A picture, or a PDF opened from disk that holds only scanned pages, has its text recognized on your computer first; the bar shows how far along that is. Words inside an image on a scanned page are not searched. ## Tell the editor what to do The last icon on the rail, a robot in a speech bubble, opens the **AI Assistant**, and `⌘/Ctrl` + `K` opens it with the cursor in its box. Type what the capture should become, in any language, and press `Enter` (`Shift` + `Enter` starts a new line). Until you send one, the panel offers two to start from, and a click sends it: - "A4 PDF with the stamp below" - "Blur the email addresses" It is a conversation, so a follow-up builds on what came before: "and put the stamp below" after "A4 PDF" changes only the stamp. A question about the file ("what format will it be?") gets an answer and no change. When a request is unclear, it asks what you meant, and when it cannot do what you asked, it says so and where in the editor it is done by hand. The Assistant is a preview, badged **Preview** beside its title. Page Scanner can close it, or only its server, while it is one: closed, its icon and `⌘/Ctrl` + `K` are gone, or a red note at the end of its conversation says the server is closed for now and the Assistant reads nothing. A message can take the Assistant a few steps: it looks, acts, reads what came of it and goes on until it answers in a sentence, for at most 8 steps. Looking runs by itself, each a line with a check or a cross: reading the editor's choices, finding sensitive text, finding words, zooming and picking a tool. A change to the file waits. The Assistant lists every change it wants as a numbered plan and runs nothing yet, and above the box it asks **Run these steps?** on a card of its own, the same way the side panel asks before a scan. Press `⌘/Ctrl` + `Enter`, or **Run**, to carry it out; the shortcut works from anywhere in the editor while the Assistant is open, unless you are typing in another field. **Cancel**, `Esc` in the empty box, or sending a new message drops the plan, which is marked "Not run.", and the Assistant goes no further with it. Each line turns into a check or a cross as it runs, with a sentence saying what happened; a line that cannot run says why, and the rest still run. The Assistant then says what changed. **Undo**, under a plan that ran, puts back the choices it changed, the crop and what it hid, but only what is still as the plan left it: a padding you changed after a plan that set the window stays yours, and a hide is not taken back once the marks have changed since. When nothing is left to put back, it says so. A zoom, a tool, a find, a copy and an export are not taken back. "Undo that", said to the Assistant, sets the choices back too. It can set the format (PDF, PNG, JPEG, Markdown or Word), the page size and the page breaks, text in pictures, PDF/A, tidying, the window and the padding, the stamp, the integrity record and the reference file; crop to the main content or the whole page; zoom; pick a tool; find sensitive text of a kind and hide it by redaction, blur or erase; find words; undo and redo; copy the crop as a picture; and export. It does it with the panels' own controls, so every change shows in its panel and on the stage. It does not draw marks, move the crop by a number, or set colors, the stamp's time, a brand, a watermark or a preset. It cannot see the page, so it answers nothing about what the page says. Every message is read by a model on **Page Scanner's server**: 10 messages a month for each install, free, each counted once however many steps it takes. With each step the server is sent the conversation so far, the editor's choices, and counts such as "2 email addresses listed"; never the page's text, pictures, address or title. A message that fails before the model reads it is not counted. Nothing is read on your computer, so the Assistant needs the network, and **Page Scanner's server** switched on in [Settings › AI Model](https://docs.pagescanner.app/extension/settings#page-scanners-server). The first line of each answer says how many of this month's messages are left: "Read by Page Scanner's server · 7 of 10 left this month". The conversation lasts as long as the editor tab, and a new capture starts a new one. A capture scanned from the [side panel](https://docs.pagescanner.app/extension#say-how-to-scan-in-the-side-panel) opens with the Assistant up and what you said there in it. When a message would not be read, a red note at the end of the conversation says so before you send it: offline, this month's messages used, the server unable to take requests, or the server switched off or closed for now. While the server reads a step, the seconds are counted and **Stop** (or `Esc`) stops it. When it cannot read one, the message stops where it was, and a note says why: | Why | What you can do | | --------------------------------------------------- | ---------------------------------------------------------- | | Offline | **Try again** once the network is back | | Not reached, too slow, busy, or a model that failed | **Try again**, which goes on where the message stopped | | This month's 10 are used | Wait for the date it gives | | Today's requests from your network are used | Try again tomorrow | | The server cannot take requests right now | Try again later | | The server is closed to the Assistant for now | Use the panels and the toolbar until Page Scanner opens it | | The server is switched off | Switch it on from **AI Model settings** in the note | | Stopped | **Try again**, which goes on where the message stopped | | It used all 8 steps | Say what is left in a new message | | A plan waited more than 30 minutes | What ran is done; send a message to go on | ## When the capture was cut short A page taller or wider than 60,000 CSS pixels is captured up to that point and no further, unless **Maximum page height** in the [settings](https://docs.pagescanner.app/extension/settings#maximum-page-height) lets it go taller. The message that confirms an export then says so first: what the page measured and how much of it is missing, so a partial page never passes for a whole one. --- # Shortcuts Every key and gesture the editor and the toolbar panel answer to. The editor's **Help** button, the question mark at the foot of the rail on its right edge, opens this page. The keys are the same on every system; `⌘` is on a Mac and `Ctrl` everywhere else. They are the letters your keyboard types. On a keyboard that types no Latin letters, such as Korean with Hangul on, Russian or Greek, press the key that carries the Latin letter: `C` is crop without switching back to English input. Hold `⌘` (`Ctrl` on Windows) for a moment and every button a `⌘/Ctrl` shortcut presses shows its key in a green badge: the panel icons on the rail, zoom in and out, Undo, Redo, Extract and the settings gear. Let go and the badges go. ## Scanning | Action | How | | ---------------------------- | ----------------------------------------------------------------- | | Open the Page Scanner panel | `Alt` + `Shift` + `P`, or the toolbar icon | | Scan the page | `Enter` in the panel, where **Scan this page** is already focused | | Pick one element to capture | `Alt` + `Shift` + `E` on the page | | Take in the element's parent | `↑` while picking, and `↓` to go back | | Capture the picked element | Click, or `Enter`; `Esc` cancels | ## Crop and marks A right-click on the stage opens a menu of the same actions, each with its key, and one more: **Crop to what is on screen**. | Action | How | | --------------------------- | ----------------------------------------------------------- | | Copy the crop as a PNG | `⌘/Ctrl` + `C` | | Crop | `C`, then drag the frame's edges | | Move the crop | Drag inside the frame | | Draw a mark | `R`, `O`, `L`, `A` or `H`, then drag | | Write on the page | `T`, then click and type | | Stamp an emoji | `E`, pick one, then click | | Number the steps | `N`, then click each in turn | | Show a close-up | `M`, then drag round the detail | | Hide something | `B` blurs, `X` redacts, `W` erases, then drag | | Cut a band out of the file | `K`, then drag down across it | | Mark up the words | `H`, `B`, `X` or `W`, then drag across the text | | Keep it square, or straight | Hold `Shift` while dragging | | Select a mark | `V`, then click it | | Remove an element | `D`, click it, then **Remove** | | Delete a mark | `Delete` | | Undo, redo | `⌘/Ctrl` + `Z`, `⌘/Ctrl` + `Shift` + `Z` | | Back out | `Esc`: the find bar, the selection, the tool, then the crop | ## View and file | Action | How | | -------------------- | -------------------------------------------------------------------------------------- | | Zoom in or out | `⌘/Ctrl` + `+` or `-`, pinch on a trackpad, or `⌘/Ctrl` + scroll | | Pan | Drag the background, or scroll with two fingers | | Fit to window | **Fit to window** in the zoom menu, or the stage menu | | Actual size (100 %) | The stage menu | | Extract the file | `⌘/Ctrl` + `P`, or **Extract** at the right end of the toolbar | | Open a panel | `⌘/Ctrl` + `1` to `7`, in the rail's order; again to close it | | Ask the Assistant | `⌘/Ctrl` + `K`, then type what you want and `Enter`; `⌘/Ctrl` + `Enter` runs the steps | | Fold the panel | `⌘/Ctrl` + `B`, or the button at the head of the rail | | Settings | `⌘/Ctrl` + `,`, or the gear at the foot of the rail | | Find in the capture | `⌘/Ctrl` + `F`, then `Enter` for the next hit and `Shift` + `Enter` for the one before | | Next or previous hit | `⌘/Ctrl` + `G`, `⌘/Ctrl` + `Shift` + `G`, while the find bar is up | ## Site map The map of a site keeps the editor's keys for what it shares with the editor. | Action | How | | --------------- | ---------------------------------------------------------------- | | Zoom in or out | `⌘/Ctrl` + `+` or `-`, pinch on a trackpad, or `⌘/Ctrl` + scroll | | Pan | Drag the background, or scroll with two fingers | | Extract the map | `⌘/Ctrl` + `P`, or **Extract** in the toolbar above the map | | Open a panel | `⌘/Ctrl` + `1` for **Format**, `2` for **Pages** | | Fold the panel | `⌘/Ctrl` + `B`, or the button at the head of the rail | | Settings | `⌘/Ctrl` + `,`, or the gear at the foot of the rail | ## Recorded steps The steps view of a [recording](https://docs.pagescanner.app/extension/record-steps) keeps the editor's keys for its tools and its file. | Action | How | | ------------------------- | --------------------------------------------------------------------- | | Previous or next step | `↑` or `↓`, when no mark is selected | | Pick a tool | `V` select, `N` step number, `X` redact, `B` blur, `R`, `A`, `H`, `T` | | Delete a mark | `Delete` | | Undo, redo | `⌘/Ctrl` + `Z`, `⌘/Ctrl` + `Shift` + `Z`, a deleted step included | | Keep a rewritten sentence | `Enter` in its field; `Esc` puts it back | | Extract the guide | `⌘/Ctrl` + `P`, or **Extract** at the right end of the toolbar | | Open a panel | `⌘/Ctrl` + `1` for **Steps**, `2` for **Sensitive Text** | | Fold the panel | `⌘/Ctrl` + `B`, or the button at the head of the rail | ## Storyboard A [storyboard](https://docs.pagescanner.app/extension/scroll-storyboard) of a page's scroll keeps the editor's keys for its marks; it has no crop. | Action | How | | -------------------------- | ------------------------------------------------------------------------------------------ | | Pick a scene | Press its row, or `Tab` to it and `Enter`; `↑` or `↓`, when no mark is selected | | Play, pause | `Space` | | Open or close the flipbook | `F`, or `Esc` to close | | One frame back or on | `←` or `→` | | Pick a tool | `V` select, `R`, `O`, `L`, `A`, `H`, `T`, `N` step number, `E` emoji, `B` blur, `X` redact | | Put Select back | `Esc`, after a first `Esc` lets go of a selected mark | | Delete a mark | `Delete` | | Undo, redo | `⌘/Ctrl` + `Z`, `⌘/Ctrl` + `Shift` + `Z` | | Zoom | `⌘/Ctrl` + `+` and `-`, or pinch | | Open or fold the panel | `⌘/Ctrl` + `1` for **Scenes**, `⌘/Ctrl` + `B` | | Extract the PDF | `⌘/Ctrl` + `P`, or **Extract** at the right end of the toolbar | [The editor](https://docs.pagescanner.app/extension/editor) explains what each tool does, and [Export](https://docs.pagescanner.app/extension/export) what each choice puts in the file. --- # Export Choose what the file will be in the panels beside the stage, watch the stage show it, then press Extract. The editor has two places for the output. The panels beside the stage hold everything that decides what the file looks like, and the stage draws each choice as you make it. **Extract**, the green button at the right end of the toolbar, or `⌘/Ctrl` + `P`, then writes the file at once. ## The panels A column of icons runs down the editor's right edge, and each opens a panel beside the stage. From the top: - **Output Format**: the format, and then, for a PDF, the page layout, the page breaks, text in pictures and archiving; for Markdown or Word, what the crop holds and tidying; for CSV, the tables it will write; for PNG or JPEG, the pixel size, and for a JPEG its quality. - **Frame**: padding, a border and a window. - **Stamp & Brand**: the stamp, your logo and a name, and a watermark. - **Integrity**: an integrity record beside the file, and what the page declares to cite it by, with a reference file beside the export. - **Sensitive Text** finds what should not be shared and hides it; [the editor guide](https://docs.pagescanner.app/extension/editor#mark-up-the-capture) covers it. - **Presets**: your saved sets of choices, applied with one click (see [Presets](#presets) below). - **AI Assistant**, last in the column: much of the above from a sentence, such as "A4 PDF with the stamp below", though not the pixel size, the JPEG quality, the border, the brand, the watermark or a preset; [the editor guide](https://docs.pagescanner.app/extension/editor#tell-the-editor-what-to-do) covers it. The icons have no names on hover; the panel each opens is headed by its name. The editor opens with the panel folded, so the stage has the whole width; the button at the top of the column unfolds it on Output Format, and an icon unfolds it on its own panel. With a panel open, click another icon to switch to its panel, and click the open panel's icon, or the button at the top of the column, to fold it away again; your choices stand either way. Inside a panel the choices come in groups, each with a title. Each option is one line; hold the pointer over it to read what it will produce for the crop you have drawn: the page count, the pixel size, the paper dimensions, the scale. With **Remember the last choices** on in [Settings](https://docs.pagescanner.app/extension/settings), your choices carry over to the next capture; it is off at first, and a preset keeps a set of them under a name. ### Format - **PDF.** Text stays selectable and artwork stays vector. Only the text inside the crop is in the file: what the crop leaves out, a site's menu or a sidebar, is not there to be found by a search or picked up by a copy. For a raster capture the option's hint says instead that this PDF holds an image. - **PNG.** Lossless. - **JPEG.** Much smaller, and lossy. Its quality is a slider in the Output Format panel. For an image the panel shows the pixel size the file will come out at, frame included. ### Text in pictures When the crop holds text that is a picture, the Output Format panel offers **Text in pictures** for a PDF: a capture that fell back to stitching screenshots is one picture, some maps, charts and document viewers draw their text into a canvas, a page's screenshots, charts and diagrams are often image files with words in them, and a picture or a scanned PDF you opened from disk is all picture. When Sensitive Text has already read an opened file, its text is reused. **Recognize it, on this computer**, the default, reads that text when you extract and lays it over the picture invisibly, so the PDF can be searched and the words selected and copied. It reads English, Korean, Japanese, Simplified Chinese and Italian, with nothing downloaded and nothing sent anywhere, and it takes a few seconds for a canvas or a picture, longer for a whole page or a page of many pictures. Recognized text can have mistakes, and it is not the page's own, which the panel says. Nothing under a blur, a redaction or an erase is read into the file. **Leave it a picture** skips it. ### Markdown and Word **Markdown** gives you the text of the crop instead of a picture of it: headings, paragraphs, lists, quotes, code, tables and images, with links, bold and italics kept, and the page's title, address and capture time at the top. It is read from the page itself as it was captured, so what is in the file is what the crop holds, less any band you cut out. Images are inside the file, so it stands alone. The panel counts what you will get before you extract. **Word** writes the same text as a `.docx` document to edit: headings in Word's heading styles, numbered and bulleted lists, tables whose header row repeats on every page, code, and the pictures. It is laid out on A4 with inch margins. Neither is offered while a blur, a redaction or an erase is on the capture, because the text under it would be in the file. The frame, stamp, brand and watermark are drawn on a picture, so they are not in either, and the Frame and Stamp & Brand panels say so instead of offering them while one is chosen. Neither is offered for a file opened from disk, which has no page structure to write. Text a page draws into a canvas is not in it, and a table cell comes out on one line. A table drawn without a table element is still a table when the page marks it as one (a data grid, or a pricing comparison built with table roles) or lays it out as a CSS grid of short cells. A data grid that scrolls inside itself gives the rows it was showing, and a check mark with no name comes out as an empty cell. A discussion thread keeps its comments apart. A comment in a list keeps its paragraphs and code under it, each reply at its depth, and a site that lays its thread out in tables, as Hacker News does, gives each comment as its author line and its paragraphs, with the code in code blocks rather than a table of one cell, each reply nested under the comment it answers. Code a site draws inside its own components, as MDN draws its examples, comes out as code blocks too, and so does a code editor on the page, such as MDN's "Try it" box. A code block's label and buttons, when the page draws them, come out as a line above it. **Tidy** decides what else goes in. **As on the page** keeps every block in the crop. **Tidied by Chrome's model** asks Chrome's own on-device model which blocks are the page around the article (menus, sign-in links, breadcrumbs, share and subscribe prompts, ads, cookie notices, "related" and "most read" lists, the footer) and leaves them out, and which short lines are section titles, and makes those headings. The model only picks blocks; every word in the file is still the page's. If it would leave out most of the page, nothing is left out. The message after the export says what it did. It takes a few seconds for each screenful of text, and it is not perfect: on our test pages it found about nine pieces of furniture in ten, and very rarely took out a line of the article. It needs a Chrome that has the built-in model, or a model you serve on this computer, chosen in [Settings › AI Model](https://docs.pagescanner.app/extension/settings#ai-model); the option then names that model. Where there is none, the Tidy group offers a small model to download and run in the browser instead, with its size on the button, and choosing the option before that shows a warning and the file is written as on the page. The first time, Chrome downloads the model, which can take a while; the export's message gives Chrome's percent when Chrome says one, and otherwise how long it has been downloading. The text never leaves your computer. ### CSV **CSV** writes the tables in the crop as spreadsheet files, to open in Excel, Numbers or Google Sheets: one table gives a `.csv`, several give a `.zip` with a CSV for each, in the page's order. They are the tables Markdown and Word see, so a pricing comparison or a data grid drawn without a table element is there too when the page marks it as a table. The panel counts the tables and their rows and columns before you extract. CSV is not offered when the crop holds no table, and not wherever Markdown and Word are not. A check mark with no name is an empty cell, a cell spanning several columns is written in the first of them, and a data grid that scrolls inside itself gives the rows it was showing. An agent or a script gets the same tables as JSON from the [command line](https://docs.pagescanner.app/cli/commands#tables-as-data). ### Archiving A PDF can be made as **PDF/A-2b, for archives**, the ISO format libraries, courts and the public sector keep documents in. The file carries every font it uses, names its color profile and holds the metadata an archive checks for, so it opens the same in decades. It looks the same as the ordinary PDF, and it is up to half a megabyte larger for the fonts inside it. A text mark in Serif, Mono or italic becomes a picture of its words in such a file, with the words still selectable and searchable. **An ordinary PDF** is the default. ### Links A PDF keeps the page's links: a link to another site opens it, and a link to a heading further down the page jumps to the sheet it landed on. A link under a blur, a redaction or an erase is left out, because where it points can give away what the mark hides. PNG and JPEG are pictures, so they have no links. ### Page layout For a PDF, choose the paper. - **A4 pages**, the default. 210 × 297 mm. - **US Letter pages.** 8.5 × 11 in. - **Phone screen pages.** 390 × 844 px, a phone's screen, with no margin: the crop is fitted to the width and cut into screens top to bottom, for reading the file on a phone. A capture at the phone width lands on it at 100 %. - **Single long page.** One page exactly the size of the crop, with no margin and no scaling. A4 and Letter keep a half-inch margin on every edge, scale the crop to fit the width inside it, and slice it top to bottom into as many pages as it takes. Each option's hint states the scale it applies and what that does to 16 px body text, in points, so you can see before you commit whether the result is worth printing. A desktop-width page shrinks a long way onto a sheet, and small print is the normal outcome rather than a fault; crop narrower if you want less of it. If the shrink is the problem rather than the crop, it is fixed one step earlier: capture the page with **Page width** set to A4 or Letter and it is laid out at the sheet's width to begin with, so this hint reads 100 % and 12 pt. [Getting started](https://docs.pagescanner.app/extension/) has that choice. For the whole page as one long PDF page, with no sheets and no page breaks, choose **Single long page**. It is the most faithful output, and its hint gives the size in inches. It warns you past 200 inches, because some PDF viewers, Acrobat among them, cut off a page that tall, and no printer takes one. That is why the default is A4. A crop taller than 60,000 pixels comes out as several long pages of equal height, none taller than that, with the breaks drawn on the preview. ### Where the page breaks fall On A4, Letter or phone screen pages a sheet holds a fixed height of the page, and left to arithmetic the cut between two sheets lands wherever that height runs out, which on a page of text is regularly through the middle of a line. For page breaks that do not cut lines, keep **Where the text allows**, the default: Page Scanner reads the capture and moves each cut up, by at most an eighth of a sheet, to the widest gap it can find, so no line is sliced in half. That can cost one extra sheet and never more, and a page with nowhere quiet to cut keeps the arithmetic break. The hint says which it will be, and **Every sheet the same** turns it off. ### Padding, a border and a window In the **Frame** panel, all off by default. A capture is the crop and nothing else, so a white page pasted onto a white slide has no edge; the frame gives it one. - **Padding** puts a margin around the capture, up to 96 px in steps of 8. **Background** under the slider picks what fills it (choosing anything but a color with no padding sets it to 48 px): a **Color** (white by default), a **Gradient** from eight swatches, a **Wallpaper** from ten desktop-style pictures made for Page Scanner (waves, beams of light, hills, petals, an aurora, dunes, and two quiet neutral ones), or a **Picture** you choose from disk (PNG, JPEG or WebP), cut to cover the margin. The picture is kept in the browser for the next capture, and the button beside its thumbnail removes it. macOS keeps its own desktop pictures as HEIC, which Chrome cannot open, so export one from Photos or Preview as JPEG first. - **Border** draws a stroke at the capture's edge, up to 8 px, in a chosen color. Mid gray by default. It sits outside the capture, so it never covers anything. - The swatch beside each slider opens Chrome's color picker. - **Window** puts a title bar above the capture so it looks like a window: **macOS**, with the three colored buttons and rounded corners, or **Windows**, in the Windows 11 style, with minimize, maximize and close and rounded corners. It has a group of its own under the frame, and once there is a bar, the menu under it picks a **Light** or **Dark** one. The bar shows the page's site name, for example `docs.pagescanner.app`. With a border on, the border goes round the whole window; with padding on, the padding is the background the window sits on, which with a gradient or a picture looks like a window on a desktop. The frame goes into the PDF, the PNG and the JPEG alike, and in the PDF it is drawn as vectors. On an image it adds to the pixel size, which the panel counts. On a single long page it adds to the page. On A4 or Letter it sits inside the margins on every sheet, so the page is scaled down to fit inside it: the scale in the page layout's hint falls as you drag, and the page cuts move with it. A window bar is on every sheet too, so each sheet looks like a window of its own. ### Presets If you switch between kinds of capture, say a bug report with a red arrow on A4 and a framed PNG for a slide, save each set of choices once and switch with one click. The **Presets** panel, the bookmark at the bottom of the rail's panels, lists your presets; click one and the pen, the text options and every choice in the panels change to it. **Save** asks for a name and keeps what the editor has now; the check saves it, and the cross (or Escape) closes the name box without saving. Saving under a name you already used replaces that preset. Point at a preset for a pencil that renames it and a bin that deletes it. Up to 20. ### Bookmarks A PDF comes out with bookmarks: every heading of the page inside your crop, nested the way the page nests them, each one jumping to the sheet it landed on. Open the viewer's sidebar to use them. Headings in the page's navigation, such as an "On this page" list or the footer, are left out, and a heading in Korean, Japanese or Chinese stays in that script. There is nothing to turn on, and a page without headings simply has no bookmarks. ### Stamp the URL and the time In the **Stamp & Brand** panel, off by default. Turn it on and the output carries a band with the page's address and the moment the capture was taken, so a file that has been printed, pasted into a document or handed on still says where it is from. - **Above** or **below** the capture. - The time can be the **date** (`2026-09-20`), the **date and time** (`2026-09-20 17:40:23`), **ISO 8601**, or left off entirely. The first two are your own time zone on a 24-hour clock; ISO is UTC, because that is the one you paste somewhere else. - **In a PDF the address is a link.** Click it and the original page opens. An image cannot hold a link, so in a PNG or a JPEG it is text. - On A4 or Letter the band repeats on every sheet and its height is taken out of the printable area, so no sheet comes out short. On a single long page, and on an image, the output grows by the band instead of the band covering the capture. - A very long address is cut from the end rather than run off the edge. - **Colors** are **Light**, white with gray text, or **Dark**, for a capture of a dark page. It is a label, not a seal. It says what was captured and when the capturing machine's clock said it was; it is not proof of anything and is not meant to be. ### An integrity record In the **Integrity** panel, off by default (**None**). **A record beside the file** writes a second file beside the export, `.integrity.json`, with the file's SHA-256, the page's address and title, a digest of the page's HTML as the scan found it, and when it was captured and exported by this computer's clock. When [Clean up before capture](https://docs.pagescanner.app/extension/settings#clean-up-before-capture) hid anything, the record counts how many of each kind, so it says the file is not the whole page. A PDF carries the same details in its own metadata. **The record, signed** also signs it with a key made in this browser the first time you use it; the panel shows the key's thumbprint, which is what you give someone so they can tell your records from anyone else's. To check a file later, with the record beside it: ```bash npx @page-scanner/cli verify terms.pdf ``` or compare `shasum -a 256 terms.pdf` with the record's `file.sha256` by hand. What it shows is narrow: that the file is byte for byte the one exported, and, when signed, that whoever holds the key made the record. It does not prove the time, which is your computer's clock, or what the page showed anyone else. The key cannot be copied to another browser, and removing the extension removes it; records it already signed still check out. The second file is a second download, so Chrome may ask once whether the extension can download several files. ### What the page declares to cite it by Many pages say in their markup who wrote them, when, and where they were published: journals and repositories write citation tags for Google Scholar, news and blog platforms write schema.org data, and library and government pages write Dublin Core. Page Scanner reads these when it scans and puts them in the file: the PDF's document properties name the authors (and its metadata adds the date, the DOI, the publisher, the language and the canonical address), a Markdown file's front matter lists everything the page gave (`author`, `published`, `publication`, `volume`, `issue`, `pages`, `doi` and the rest), and a Word file's properties name the authors. The **Citation** group in the **Integrity** panel shows what was found and where from. **A reference file beside it** also downloads a `.ris` file with the same name as the export, which reference managers import: the kind of work, the title, the authors, the date, the journal, the volume, issue and pages, the DOI, the address, the day you captured it, and the exported file's name. Where the page declares nothing, the reference carries its title, its address and the day. This is what the page says about itself, copied as written. Nothing is looked up or checked, so a page with the wrong author or date gives a file with the same. Many news and government pages declare a title and little else, and show the reporter and the date on the page instead: "김민수 기자", "입력 2026.09.25 14:30", "By Jane Doe". Where the page declares no author or no date, Page Scanner reads its byline and offers what it found under the declared fields, with **Use these**. Nothing of it goes into a file until you press that, so check it against the page first. A date after 수정 or Updated is never taken as the publication date. ### A page you had translated Chrome (and Edge) can translate a page before you scan it, and the capture keeps the translation as real, searchable text. So that nobody later quotes it as the author's words, Page Scanner notes it: the editor says so as the capture opens, the **Citation** group starts with "Machine-translated by Chrome before the capture", the PDF's Subject ends with the same, a Markdown file's front matter has `translated: "Machine-translated by Chrome"`, a Word file's description says it, and a reference file carries it as a note. The language it was translated from and to is not recorded. ### The page's language Every PDF says which language the page is in, taken from the page itself, so a screen reader can read it in that language. A page that does not say is given the language Chrome detects in its text, on your computer, and text in its pictures is read with that language. Chrome detects it with the model its own translate feature uses, and only when that model is already on your computer; nothing is downloaded for it. A page written in two languages is given the one it opens with. ### Your logo and a name In the **Stamp & Brand** panel, off by default. **Brand** puts a logo and a name on the output, for a capture you send to a client or post in public. - Pick where it goes: **In the stamp band**, at its start before the address, or a corner of the capture: top left, top right, bottom left or bottom right. In a corner it sits on a small white plate so it reads over any page. - Type a name, up to 60 characters, and choose a logo: a PNG, JPEG, WebP or SVG file up to 5 MB. The logo is kept in the browser and used by every capture after this one, until you change it or remove it. Untick it to leave it off without forgetting it. - With the stamp off, a brand in the band still adds the band, at the bottom, holding the brand alone. - On A4 or Letter every sheet carries it. - A name in Korean, Japanese or another script the PDF's standard fonts cannot draw is drawn as a picture of itself in the PDF. It looks the same, but you cannot search for it there. ### A watermark Type a word, such as DRAFT or CONFIDENTIAL, under **Watermark** and it is repeated at an angle across the capture, in gray at the strength you choose: **Faint**, **Medium** or **Strong**. On A4 or Letter it is laid across every sheet. In a PDF it is a picture rather than text, so searching or copying the page's text does not turn it up. It labels the file; anyone with a PDF editor can delete it, so it does not protect it. ## See it on the stage With A4 or Letter selected, the cuts are drawn straight onto the capture and numbered, so you can see which part of the page lands on which sheet before you export. They follow the printable area inside the margin, not the edge of the paper. A frame is drawn around the crop in its colors, and a stamp as a band above or below it reading what the file will read, and the brand and the watermark where they will be; the page outside them is dimmed, so the crop and what the file adds around it read together. ## Extract **Extract** is the green button at the right end of the toolbar, over the top of the stage, and `⌘/Ctrl` + `P` or **Extract** in the stage's right-click menu does the same. One press writes the file the panels describe, as a download, with nothing to confirm. If it is not what you wanted, change the panel and extract again. The message that confirms the download says what the file was made with, naming only what is on: for a PDF the page count and the paper, and PDF/A-2b when archiving is on; for an image its pixel size, and the quality for a JPEG; then the frame, the stamp, the brand and the watermark. A Markdown or Word file has none of these. If the capture was cut short, the message says how much is missing first. With **When something is done** turned off in the [settings](https://docs.pagescanner.app/extension/settings#notifications), there is no message. ### Copy as PNG To paste the crop straight into another app, press `⌘/Ctrl` + `C`, or right-click the stage and choose **Copy as PNG**. It copies a PNG whatever format the Output Format panel has chosen, because Chrome's clipboard will not accept a JPEG or a PDF. ### Quality A JPEG's quality is a slider in the Output Format panel's Image group, from 40 to 100 %, set to 90 % by default. ### After the second export Right after your second export, a small card appears in the bottom-right corner of the stage, asking whether you are enjoying Page Scanner, and saying that a review on the store it came from (the Chrome Web Store, or Edge Add-ons in Edge) would be an encouragement to keep building. **Write a review** opens the listing's reviews page in a new tab; the close button puts the card away. It does not time out, and once you close it it does not come back. The count is kept in the browser's own storage and is not sent, and whether you reviewed is not recorded. Each export is counted in the [usage statistics](https://docs.pagescanner.app/extension/settings#report-usage-statistics), unless you turned them off. ### The file name The page's title, or its address when it has no title, followed by the date and time of the export and the format's extension. Letters and digits are kept in whatever script the title is in, so a page titled in Korean or Japanese gives a file named in Korean or Japanese; spaces and punctuation become hyphens. --- # A page and its terms in one file Capture a checkout page together with the terms it links to, each with its own address and the time, in one PDF or a ZIP of files. A checkout page shows a price and links to its terms, and either can read differently the next day. To keep what both said on the day, capture them together. There is no separate mode for it: it is the tabs scan, the stamp and the integrity record, in that order. 1. **Open the linked pages in tabs.** On the checkout page, `Cmd`-click (`Ctrl`-click on Windows and Linux) each link you want kept: the terms, the refund or cancellation policy, the shipping page. 2. **Select the tabs.** Click the checkout page's tab, then `Cmd`/`Ctrl`-click each of the others, or `Shift`-click to take a run of them. Two to ten tabs, from one window. 3. **Keep the pages as they were shown.** If [Clean up before capture](https://docs.pagescanner.app/extension/settings#clean-up-before-capture) has anything ticked, untick it, so no banner or overlay is taken out of the file. 4. **Scan.** Open Page Scanner from the toolbar and press **Scan 3 tabs** (the count is how many you selected). Each tab is captured in turn into one capture, in tab order, under a band with its title. 5. **Stamp each page.** In the **Stamp & Brand** panel, turn the stamp on with **Date and time**, or ISO 8601 for UTC. In a PDF each tab's pages carry that tab's own address, as a link. 6. **Write a record beside it.** In the **Integrity** panel choose **A record beside the file**, then **Extract**. The PDF has a bookmark for each tab, so the terms are one click from the price. Beside it, `.integrity.json` holds the file's SHA-256 and when it was captured and exported, and checks the file later: ```bash npx @page-scanner/cli verify checkout.pdf ``` For a file per page instead of one document, choose **A file per tab, in a ZIP** under **Tabs** in the **Output Format** panel. Each tab becomes its own file with its Markdown beside it, with an index and a `SHA256SUMS` file covering every file in the ZIP; the integrity record is not written for a ZIP, because those digests take its place. ## What it does not do - **It does not open the links for you.** Page Scanner captures the tabs you select and no other page, so the terms are in the file only if their tab was selected. - **The time is your computer's clock.** The stamp and the record say when this computer captured the pages, not a time anyone else vouches for. - **The record is narrow.** It says that a file is byte for byte the one you exported, and nothing about what the site showed anyone else. It is a label kept with the file, not proof of anything. A page behind a sign-in is captured as you see it, since the scan runs in your own Chrome. The [export guide](https://docs.pagescanner.app/extension/export) has every option the panels offer. --- # Map a site Capture up to 30 pages of a site and see them as a flow, each page joined to the pages it links to, ready to open in the editor. A site map captures the pages of one site and lays them out side by side, the start page first and a column for each step away from it, with a line for every link between them. Use it to review a site's structure, hand over a set of screens, or keep how a small site looked on a day. It is a preview: the popup marks it with a green dot until you first use it. 1. **Open the page to start from**, usually the home page, and click the Page Scanner icon. 2. **Press Map this site**, under **Pick an element**. The map opens in a tab of its own. Nothing has been read yet. 3. **Choose how far to go.** **2 links deep** takes the start page, the pages it links to and the pages those link to; **3 links deep** goes one step further. 4. **Press Find pages.** Chrome asks you to let Page Scanner read the site, for example every page under `example.com`. Allow it. Page Scanner then reads the site's pages to list them, which takes a few seconds. Each page appears below as it is read. 5. **Read the list.** It shows the pages it will capture, in order, and the ones it leaves out and why. Pages of one kind, such as blog posts, are one row that says how many others are like it, and only that one is captured. 6. **Press Capture N pages.** Each page opens in a background tab, is captured the way a scan is, and closes again. The map grows as each one is done. **Cancel** stops it, and closing the map's tab does too; what was captured stays. ## Reading the map Each page has its address at the top, colored by how it stands to the start page: - **Same host** (green, a house): the start page's own host, such as `www.example.com`. - **Another subdomain** (blue, layers): another host of the same site, such as `docs.example.com`. - **Another site** (grey, an arrow out of a box): a link that leaves the site. It is drawn as its address only, never opened or captured. A page opens on its first screen. The buttons at its top fold it to its address alone or unfold it to the whole page, and the toolbar above the map does the same for every page. A page that answered with an error, such as `404`, says so in red beside its address; one that could not be captured says why. The **Pages** panel on the right lists the pages by how many links they are from the start page, one section per column of the map, and takes you to any page. The rail beside it works as the editor's: its buttons switch between **Format** and **Pages**, `⌘/Ctrl` + `B` folds the panel away, and the gear at its foot opens the settings. The editor's keys for zooming, extracting and the panels work here too ([Shortcuts](https://docs.pagescanner.app/extension/shortcuts)). **Open in editor** on a page, or a double-click, opens its capture in the editor, where it crops and exports like any scan. ## Save the map, or paste it into Figma Choose what to make in the **Format** panel, then press **Extract** at the right of the toolbar above the map (or `⌘/Ctrl` + `P`): - **PNG** saves the whole map as one picture, named after the site (`example.com-map.png`). - **SVG** saves it as a drawing (`example.com-map.svg`). The cards, addresses and links stay sharp however far you zoom in, and the addresses are text you can search and edit. - **Figma** copies the same drawing to the clipboard. In a Figma file, paste it with `⌘V` (`Ctrl+V` on Windows): each page comes in as a layer named by its address, with its text in Inter. Each page is in it as it is folded on the screen, so fold the pages first to make the map as long or as short as you want: addresses only, first screens, or whole pages. Pages off screen are in it too. The pages' pictures are small in every format, enough to recognize each one; to read a page, export it from the editor. ## What it reads, and what it leaves alone - **It stays in the site you started from.** `example.com`, `www.example.com` and `docs.example.com` are one site; `a.github.io` and `b.github.io` are two. - **It never follows a link that would do something**: an address that says sign out, log out, delete, unsubscribe or cancel. The pages open in your own browser, signed in as you are, so this matters. - **It opens no files** (PDFs, images, feeds, archives), follows no link marked `nofollow`, and keeps to what each host's `robots.txt` allows, except for the page you started from. - **It slows down when a site asks it to.** Pages are captured a second apart. A site that answers "too many requests" is left alone for a while and asked again. - **A check that you are a person is yours to pass.** When a site shows one ("Just a moment…", "Performing security verification"), the map stops, brings that tab to the front and waits. Pass the check there, and the map captures the page, comes back and goes on by itself. **Show tab** brings the check back if you moved away, and **Skip page** leaves that page off the map. After 5 minutes without it the page is left off, and the check screen is never put on the map as the page. - **Up to 30 pages are captured**, one per kind of page. A larger site lists the rest as "Past 30 pages". - **Nothing leaves your computer.** The pages are read and captured by your browser, and the map is kept with your captures for 12 hours. While the pages are captured, Chrome shows its debugging bar, as it does for every scan, until the last page is done. See [the bar during a scan](https://docs.pagescanner.app/extension/debugger). ## Limits - The list is read from each page as it is first served. A link a page adds with JavaScript after it loads is not followed, though the map still counts it on that page. - Three links deep and 30 pages at most. - The map saves as a PNG or an SVG, or goes to Figma through the clipboard, always drawn from small pictures of each page; a page's full capture exports from the editor. An SVG of many whole pages can be a few MB, since the pictures are inside it. - Chrome keeps the access you gave to the site until you remove it on Page Scanner's details page (`chrome://extensions`, **Details**, **Site access**). - One map is made at a time. --- # Record steps Click through a task once and get a step-by-step guide, a picture and a sentence for each click, with sign-in and ID fields covered, as one PDF. Record steps turns a task you do in the browser into a guide: each click that changes the screen becomes a step, with a picture of the screen, a number on what you clicked and a sentence that says it. Use it to show a colleague how to file a form, to hand over a routine, or to write down how a setting is changed. It is a preview: the popup marks it with a green dot until you first use it. 1. **Open the page to start from** and click the Page Scanner icon. 2. **Press Record steps**, under **Map this site**. The popup closes, Chrome's debugging bar comes up over the page, and the Page Scanner icon shows a red count of the steps taken. 3. **Do the task**, at your own pace. Sign in, fill in fields and click through as you normally would. A click that only puts the cursor in a field or ticks a box is not a step; a click that opens the next screen is. 4. **Click the Page Scanner icon and press Stop and open the steps.** The steps open in a tab beside the page. The recording also stops if you press **Cancel** on the debugging bar, open DevTools on the page, close the tab, take 100 steps or go on for 30 minutes. Whatever was recorded is kept, and the steps open all the same. ## What is kept, and what is covered Each step keeps the part of the page that was in the window before you clicked, the page's address and title, and what you clicked. What you type is not kept on its own anywhere; it shows only where it was on the screen. Fields for a sign-in, a password, a one-time code, a card or an ID number (a resident registration or business number, for example) are found on each screen and covered with a black box in that step's picture, in English and in Korean labels. A field of any other kind shows what you typed in it, as it did on your screen, so look through the pictures before you share a guide. ## Edit the steps The steps view lists every step in the **Steps** panel on the right and shows the selected one in the middle: - **The number** sits on the corner of what you clicked, and the covered fields are black boxes. Both are ordinary marks: select one to move or delete it, or add more with the toolbar (step number, redact, blur, rectangle, arrow, highlighter, text). - **The sentence** is written for you ("Click **Sign in**"). Rewrite it in the field under the selected step and press `Enter`. - **Move a step** with the arrow buttons, and **delete** it with **Delete step**. `⌘/Ctrl` + `Z` undoes any change, a deleted step included. - **Add a picture** or **Add a sentence** puts a step after the selected one, for something done outside the browser: a screenshot of another program, or just an instruction. - **Sensitive Text**, the panel's second button, runs a Pattern Scan over the text of every step and lists email addresses, phone and card numbers and the like by step. Open the step and draw a redaction or a blur over each one you want hidden. `↑` and `↓` move through the steps. The editor's tool letters and its `⌘/Ctrl` keys for undo, the panels and Extract work here too ([Shortcuts](https://docs.pagescanner.app/extension/shortcuts)). ## Save the guide as a PDF Press **Extract** at the right of the toolbar (or `⌘/Ctrl` + `P`). The PDF has one A4 page per step, in your order: "Step 3 of 7", the sentence, the picture with its marks, and at the foot the address the step was on, as a link, and when. Every step is a bookmark. The covered fields are black in the pictures themselves, so nothing under them is in the file, and the words in the pictures are read on your computer so the PDF can be searched. The file is named after the first page and the day, for example `taxdesk-steps-2026-10-01.pdf`. ## Limits - A picture is what was in the window, not the rest of the page below it. - Only the fields described above are covered. An on-screen keypad a site draws for its password is a picture, not a field, and is not covered. - Clicks inside a frame from another site, and anything outside the tab (a file dialog, a certificate program, another window), are not recorded. Add them with **Add a picture** or **Add a sentence**. - The sentences are in English. - The debugging bar stays up while you record. See [the bar during a scan](https://docs.pagescanner.app/extension/debugger). - One recording runs at a time, and recordings are kept with your captures for 12 hours. --- # Scan scrolling Scroll a page once and get its scroll experience as a storyboard, scene by scene, with six frames each and what moved in words, saved as one PDF to hand to an AI coding agent or a person. Scan scrolling turns how a page behaves as you scroll into a storyboard: the page cut into scenes, each with six frames from where it starts to where it ends, what moved in it said in sentences, and how it feels when the scroll stops. Use it to show an AI coding agent, or a designer, a page whose sections pin, fade and slide as it scrolls, without recording a video. It is a preview: the popup marks it with a green dot until you first use it. 1. **Open the page** at the top and click the Page Scanner icon. 2. **Press Scan scrolling**, under **Record steps**. The popup closes, Chrome's debugging bar comes up over the page, and the page scrolls down by itself at a steady pace. The Page Scanner icon shows how far down it has come. 3. **Leave the page alone** while it scrolls. Scrolling, clicking or typing on it stops the scan. 4. **The storyboard opens** in a tab beside the page when the scan reaches the end, and the page goes back to where it was. To stop early, click the Page Scanner icon and press **Stop and open the storyboard**: what was scanned so far opens, marked as stopped short. A scan also stops after two minutes, if you press **Cancel** on the debugging bar, open DevTools on the page or close the tab. An agent can ask for a storyboard too, with [`page-scanner storyboard`](https://docs.pagescanner.app/cli/commands#a-pages-scroll-as-a-storyboard) or the MCP server's [`storyboard_page`](https://docs.pagescanner.app/mcp/tools#storyboard_page), and gets the PDF, what was measured as JSON and the frames as files, without opening the editor. While an agent's scan runs, the popup shows how far it has come and **Stop the scan**, which ends it and hands the agent what was scanned. ## Read the storyboard The storyboard is a board of the scenes, a row each, top to bottom. A row says the scene's number and title, whether the page held still there (**Pinned**), moved things as it scrolled (**Scrolls, things move**) or just scrolled (**Plain scroll**), how many screens it lasts, and how it feels: **Stops with the scroll**, **Glides** for a moment after you stop, or **Loops on its own**. Its six frames show it from entry to exit. Press a row to pick that scene; the **Scenes** panel on the right shows it: - **What happens**: what moved, measured ("The 4 words or lines of "SPACE MISSIONS MADE SIMPLE" move up 113px over 0.8 screens of scroll, one after another"). Take a line out with its ×, and bring the scene's lines back with **Put back**. A line cannot be reworded, so what the agent reads is what was measured. - **Note for the agent**: anything you want to add, in your own words. It is kept apart from the measurements. - **Text on screen**: the words that were on screen in the middle of the scene. - **Leave it out of the PDF** fades the scene on the board, for a stretch the agent does not need. The up and down arrows beside "Scene 3 of 8" move through the scenes. The board pans and zooms as the editor's stage does; **Fit** in the zoom shows all of it. ## Play it back The player at the bottom of the board goes back a scene, plays, and goes on a scene; its track has a mark at each scene's start, and it says which scene it is in. Press **Play** (or `Space`) and the flipbook opens over the board and plays the scroll at the pace it was scanned. Scroll over the flipbook, or drag the track, to move through it by hand; `←` and `→` step one frame, and `↑` and `↓` one scene. **Play in the flipbook** in the Scenes panel, the button at the player's right, or `F` open it without playing, and `Esc` closes it. The board and the player follow each other: pick a row and the player jumps to that scene, play into the next scene and its row is picked. **Use this frame** puts the frame you are looking at into the scene's strip, in the cell nearest it (the strip's six cells are the scene's start, every fifth of the way, and its end). Use it when the scan's own pick missed the moment that matters. The Scenes panel says how many frames you chose, and **Put back the scan's** undoes them. A plain scroll has no strip, so the button is off there. ## Mark the frames The toolbar is the editor's, without the crop: rectangles, ellipses, lines and arrows, the highlighter, text, step numbers, emoji, blur and redact, with the same letters ([Shortcuts](https://docs.pagescanner.app/extension/shortcuts)). Draw over the frames to point at what matters, or redact something that should not be shared. `⌘/Ctrl` + `Z` undoes a mark, and `Esc` puts Select back in hand. ## Save it as a PDF Press **Extract** at the right of the toolbar (or `⌘/Ctrl` + `P`). The PDF is the file to hand an AI coding agent: its first page is an overview of the page (its address, the window size, how long it is, how it feels, and every scene in a line), and then each scene that moves has a page of its own, with its six frames in two rows of three, what happens in it, how it feels, your note, the words you wrote on its frames, and the text that was on screen. Everything said is text the agent can read, kept apart from what you added: your note is under "Note (from the person who scanned it)", and words written with the text tool are under "Written on the frames", with the frame each was on. Your marks are drawn into the frames, at the same place in each frame they cover on the board; a redaction is black in the picture itself, so what it hides is not in the file. Scenes you left out are not in the file. It is named after the page and the day, for example `space-service-storyboard-2026-10-23.pdf`. ## Keeping it A storyboard is kept for as long as its tab is open. Your changes (the marks, the notes, the lines taken out, the scenes left out, the frames you chose) survive a reload of the tab, and Chrome asks before you close a tab with changes you have not extracted, since closing it deletes the storyboard. Extract it to keep it. ## Limits - It scrolls the page itself, not a panel that scrolls on its own inside it, so an app whose content scrolls in a box shows as one screen that holds. - A scan takes at most two minutes, which is about a hundred screens. - The frames are at most 720 px wide, so small text in them is soft. A video or a canvas drawn by script is pictures only. - The flipbook has the frames the scan kept, six to eight a second, so an animation faster than that shows as a few pictures. - An animation that only starts on a real wheel or touch, not on a scroll, does not play. - Cookie banners are not cleared first, so a banner is in the frames. - The debugging bar stays up while it scans. See [the bar during a scan](https://docs.pagescanner.app/extension/debugger). --- # Settings The choices that have to be made before a scan, the theme, notifications, the model the AI features ask, the usage statistics and the local agent pairing, in one dialog. In the editor, press the gear at the foot of the rail on the right, or `⌘` + `,` on a Mac (`Ctrl` + `,` on Windows and Linux). The settings open in a dialog over the capture; `Esc`, a click beside it or the X in its corner closes it. The same settings open on a page of their own from the gear in the panel that opens when you click the toolbar icon, from **Options** when you right-click the toolbar icon, and from `chrome://extensions`, then **Details**, then **Extension options**. On that page the X closes the tab, and `Esc` does nothing, so a stray key press does not close it. The dialog lists its sections down the left: Appearance, Capture, Editor, Notifications, Sensitive Text, AI Model, Privacy and Local Agents. Each setting is one row. The question mark beside a setting's name says what it does when you point at it. A choice is saved the moment you make it; a box you type in is saved when you click away from it. **Page width** is not here. It is the one choice that changes with the page in front of you, so it lives in the panel that opens when you click the toolbar icon; [Getting started](https://docs.pagescanner.app/extension/) covers it. ## Appearance ### Theme The editor, the popup and the settings have a light and a dark theme: the sun or the moon. The sun-and-moon button at the foot of the editor's rail switches the same setting straight to the other one, and a fresh install starts light. A captured page keeps its own colors; **Page color scheme**, under Capture, decides those. ### Canvas dots and canvas color The canvas is the surface behind the capture in the editor, and behind these settings on their own page. **Canvas dots**, on by default, draws a grid of dots on it that moves with the page as you pan and zoom. **Canvas color** picks one of four grays: White, Soft gray (the default), Gray or Deep gray in the light theme, and Black, Soft gray (the default), Gray or Light gray in the dark one. Each theme keeps its own choice, so switch the theme to set the other's. ## Capture These are set before you scan. The capture lays the page out once and takes the preview and the PDF from that one layout, so none of them can be changed for a capture you already have. ### Page color scheme A page with a dark version and a light one is captured in whichever this says, and the choice reaches the PDF as well as the preview. - **Match the browser** (the monitor), the default, captures the page the way it looks right now. - **Light** (the sun) takes the light version whatever the browser is set to. - **Dark** (the moon) takes the dark one. Leaving it on the default is also what keeps the PDF matching what you saw on screen. Chrome prints every page in the light scheme unless it is told otherwise, so a dark page used to come back as a dark preview and a white PDF. The capture tells it, whichever way the page writes its two versions: with a `prefers-color-scheme` media query, or with `light-dark()` colors under `color-scheme: light dark`, the way MDN does, which a print would otherwise render light even when told. **Light** and **Dark** also reach a page that keeps the theme you picked on the site, the way many sites built with Tailwind or next-themes do (ui.shadcn.com is one): it marks the theme with a `dark` class or a `data-theme` on the page, which the capture turns to the one you asked for and back after. **Match the browser** leaves that mark as it is, so the page comes out as you see it. A page that has only one version looks the same whichever you pick, and so does a page that chooses its theme in JavaScript some other way: its own script has already run by the time the capture starts. ### Videos A video on the page can only ever come out as a still image, and this decides what that still is. - **Paused frame**, the default, pauses the video and keeps the frame it stopped on, at its on-screen size. - **Blank** leaves the video's area empty. ### Open folded sections before capture A capture takes the page as it stands, so a section that is closed on screen is closed in the PDF too. This switch decides whether the scan opens the folded parts first. - **Off**, the default, captures the page exactly as you see it. - **On** opens every closed section, every accordion and disclosure that opens in place, and every hidden tab of a tab set (shown one below the other), then waits a few seconds for images that are still loading. After the capture it folds everything back up, so the tab is left the way you had it. A scan takes a moment longer. It never presses a plain "Show more" or "Load more" button, a link, or anything in a menu or the site's navigation. Those can load the next page of results, send a form or count a click, so a section behind one is still left closed. Nor does it open a disclosure that does not mark itself as one to the browser's accessibility tree; open that by hand before you scan. ### Check accessibility Off by default. On, each page you scan is also checked against WCAG 2.0, 2.1 and 2.2, levels A and AA, with axe-core, on this computer: nothing about the page is sent anywhere. The editor then has an **Accessibility** panel on its rail that lists what failed, rule by rule, and boxes each failing element on the page while it is open. The panel can save the capture with the boxes drawn on and the rules listed after it, as a PDF to pass on. An automated check finds some of what fails WCAG, not all of it: whether a picture's text describes it, or the page reads in a sensible order, still needs a person. A scan takes a moment longer with it on. It checks the scans that follow; a capture already open is not checked again. ### Clean up before capture A capture keeps whatever the page drew: an ad between two paragraphs, a cookie banner pinned to the bottom, a chat bubble, a newsletter pop-up and the dark layer behind it. Tick what the scan should hide first: - **Ads** - **Cookie and consent banners** - **Chat widgets** - **Pop-ups and overlays**: a pop-up window, the dark layer behind it, and a bar asking you to open the page in an app All four are on by default. Untick them all for a capture you keep as a record of how the page looked, which should keep everything. What is hidden is taken out for the length of the scan and the page is laid out again without it, so no empty box is left behind, in the PDF or the preview. After the capture it all comes back, and the tab is left the way you had it. Ads are found by the services that serve them and by the markup that ad tags write, and a frame from another site at one of the standard ad sizes counts as one; never by a word in a class name. Banners and chat widgets are found by the elements the common consent and chat services put on the page, and by a fixed bar about cookies with a button in it. A pop-up is found by being marked as one, or by covering at least half of the window above the page. When the scan hid something, the editor says what as it opens, in a notification with a **Capture settings** button that brings you straight back to these four. An [integrity record](https://docs.pagescanner.app/extension/export#an-integrity-record) counts them as well. Turn all four off when you want a record of how the page looked, since a hidden element is not in the file. The rules will miss some: an ad served from the site's own address, a banner no service built, a pop-up that is neither marked nor large. An ad blocker in your browser already keeps ads off the page, and the capture takes the page as it stands. ### Maximum page height How far down a capture goes before it stops. A page with no bottom, an endless feed or a thread that keeps loading, has to stop somewhere, and a capture has always stopped at 60,000 pixels. - **60,000 px**, the default, is where a capture has always stopped. - **120,000 px** and **240,000 px** go further, for a long thread, a long document or a feed. Past 60,000 pixels the PDF is printed in pieces and joined back into one, so it keeps its text and its sharpness. The preview in the editor, and a PNG or JPEG made from it, is one picture of the whole page, and the taller the page the coarser it gets. A single long page export of more than 60,000 pixels comes out as several long pages. The width stays limited to 60,000 pixels. Some pages draw only what is on screen and leave the rest as empty space until you scroll to it; a long ChatGPT conversation is one. When a scan finds a page like that cut short, it goes past this setting for that page, up to 10 million pixels, so the messages below the limit are not left blank. The setting itself stays as you chose it. Past a million pixels or so the editor's preview of such a page is too small to read, while the PDF keeps every message sharp and searchable. ## Editor ### Crop when the editor opens Where the crop is when the editor opens. - **Whole page**, the default, opens every capture uncropped. - **Main content** opens on the page's article or column of text when the scan found one, and on the whole page otherwise. The two carry the same icons as the two crop buttons in the editor's toolbar, which switch between them on any capture, and the crop can be dragged anywhere. ### Remembered choices **Remember the last choices** is off at first, and every capture then opens on the defaults; a look you want again is a preset, saved from the editor's [Presets](https://docs.pagescanner.app/extension/export#presets) panel. Turn it on and the editor remembers the choices you made on the last capture: the pen's color and width, the text's size and face, the blur's strength and the redaction's color, the format, the paper, the page breaks, the frame, the stamp, the brand and the watermark, and a JPEG's quality. The next capture opens on the same ones, so the second scan of the day starts where the first one ended. Turned off again, what it remembered is kept for when it is turned back on. **Reset to defaults** puts them back the way they were installed, in the next capture and in an editor that is already open, the one you opened the settings from included. The brand's logo is kept on its own, and the reset leaves it; remove it from the editor's Stamp & Brand panel. ### Tour of the editor The first editor that opens after you install Page Scanner walks through it in a few steps: the crop, the tools, Output Format, Extract, the Assistant and these settings. **Show the tour** shows it again. From the editor it starts at once; from the extension's options page, the next capture opens with it. **Next** and **Back** (or the arrow keys) step through it, and **Skip tour** or `Esc` ends it. ## Notifications The notifications that pop up at the bottom of the editor. Errors and warnings always show, because each one says something went wrong or was left out of the file. - **What was hidden before capture**: the notification that says what [Clean up before capture](#clean-up-before-capture) hid. On by default. - **When something is done**: that a file was downloaded, a picture copied, or hiding marks placed from Sensitive Text. On by default. Off, an export finishes without a word. - **How long a notification stays**: 4 seconds (the default), 8, 15, or until you close it. A notification can always be closed sooner with its ×, and one for work still going, such as an export being built, stays until the work is done. ## Sensitive Text ### Always look for Words and patterns for the editor's **Sensitive Text** panel to look for on every capture, with the emails, numbers and keys its **Pattern Scan** looks for. One per line: a word, found whatever its case, or `/a regular expression/`, such as a customer's name or the shape of your account numbers. They stay in this browser. One saved while the editor's Sensitive Text panel is showing behind the dialog is looked for there at once, once Pattern Scan has run. ## AI Model Which model the editor's AI features ask: [AI Scan](https://docs.pagescanner.app/extension/editor) in the Sensitive Text panel, and a Markdown or Word export **Tidied by** a model. Each way the text stays on your computer. The [Assistant](https://docs.pagescanner.app/extension/editor#tell-the-editor-what-to-do) and the side panel are the exception: they use **Page Scanner's server**, below, and not the model chosen here. ### Model Server One list holds every choice: **Browser Built-in**, **WebGPU**, and each server you can run yourself, marked **(Local)**. **Browser Built-in**, the default, is Chrome's own on-device model. It runs inside Chrome where your computer meets Chrome's requirements for it, and Chrome downloads it the first time a scan asks. The row says where it stands. A **(Local)** server is a model you run yourself on this computer, with a program such as [Ollama](https://ollama.com), [LM Studio](https://lmstudio.ai) or [llama.cpp](https://github.com/ggml-org/llama.cpp): Ollama, LM Studio, llama.cpp, vLLM, Jan, LocalAI, KoboldCpp, MLX LM, or **OpenAI-compatible** for any server that answers the OpenAI chat API at `/v1`. "Local" because some of them also run as a service on the internet, and Page Scanner reaches only the one on your computer. Useful where Chrome has no model for your computer, in Edge, or when you want a model of your choice. The first one you choose asks Chrome, once, to let Page Scanner reach `localhost`; nothing else is reached. Then: - **Port**: filled in with the server's usual one (Ollama 11434, LM Studio 1234, llama.cpp 8080, vLLM 8000, Jan 1337, KoboldCpp 5001). Change it if you started the server on another. - **Server model**: the models the server has that can answer. Embedding models are left out, since they cannot. The refresh button beside it asks again after you add one to the server. Page Scanner starts no server and downloads no model: start the server and pull a model in it first. On Ollama, for example: ```bash ollama pull qwen3.5:2b ``` In our test on a MacBook Pro (M4 Pro), Qwen3.5 2B found about as much as Chrome's model in less than half the time. The smallest models we tried, around 300 million parameters, took prices and company names along with the rest. **WebGPU** runs a small model in the browser itself, on your computer's graphics card, with no server and no program to install. Useful where Chrome has no model for your computer and you would rather not run a server. Then: - The first line says what the browser reports of the graphics card: whether it has WebGPU, whether it computes in 16-bit numbers, and how much memory the computer has. - **Browser model** lists the models Page Scanner has tested, with the one it recommends for that card marked. A model the card cannot run is listed but cannot be chosen. The line under it gives the download's size, how the model scored in our test, and how long it took. - **Download** fetches the chosen model from Hugging Face, once, with its progress on the line. It goes on while you open another section or close the settings, and the line shows where it stands when you come back. It is kept in the browser's cache for the next time. The bin button that takes its place removes it again, keeping any file another downloaded model still uses. Page Scanner recommends **Qwen3.5 0.8B, 16-bit** (2.0 GB) for a graphics card that computes in 16-bit numbers on a computer with 8 GB of memory, and **Qwen3.5 0.8B, 4-bit** (670 MB), which runs on any card with WebGPU, for the rest. On a MacBook Pro (M4 Pro) they took 13 and 11 seconds for every 1,800 characters, where Chrome's model took about 2. **LFM2.5 1.2B (fast)** answers in under a second and finds much less. Nothing of yours goes with the download; your text never leaves the browser. These models are slower than Chrome's and find less, so check what AI Scan found before you hide it. ### Try it The plug button asks the model about a short made-up order with five things in it to find. A green check beside it means the model found all five and nothing else. A red cross means it did not, or could not be asked, and the line under **Try it** says what it found or why. Nothing from your captures is used. You can open another section or close the settings while it runs: coming back, you see it still turning, or how it did. ### Page Scanner's server For the [Assistant](https://docs.pagescanner.app/extension/editor#tell-the-editor-what-to-do) and the [side panel](https://docs.pagescanner.app/extension#say-how-to-scan-in-the-side-panel): whether their messages may go to Page Scanner's server, which reads every one of them. A model there reads each message and answers it in up to 8 steps, through the editor's controls or the scan's choices. With each step it is sent the conversation so far, the choices and the counts the extension gives back, never the page's text, pictures, address or title. It keeps a count of messages per install: 10 a month, free, each counted once however many steps it takes, and a message that fails before the model reads it is not counted. On by default; the line under it says how many of this month's are left. Off, neither reads anything. The [privacy policy](https://pagescanner.app/privacy/) says what the server keeps. While Page Scanner has the server closed to the Assistant, the switch is off and says so, and while the Assistant itself is closed the row is not shown. ### AI Scan's prompts One row for each kind AI Scan looks for (Names, Postal addresses, ID numbers, Payment details), folded until you open it with its arrow, holds what the model is told that kind is and is not. The line "Your own prompt." under a name says you have changed it. Each model understands some prompts better than others, so they are kept per model: what you write for one model on Ollama does not change what Chrome's model is told. Empty a box to go back to Page Scanner's prompt, or press the undo button (**Reset to default**) that an edited row shows. ## Privacy ### Report usage statistics The extension counts which of its features are used and sends those counts to Google Analytics, so the features people use are the ones that get the work. The switch is on by default. - **On**, it sends one event each time something is used: the popup opening (and whether over a page it can scan, never which page), a scan ending (the width, whether it came out as a PDF with real text or as an image, and for an image or a failure the step where the PDF capture stopped (never the error's words), whether it stopped at the size limit, how the main content was found, whether you picked one element, whether collapsed content was opened first, whether it went past 60,000 pixels, whether clean-up hid anything, how long it took), a mark placed (its kind only), an export and its options (among them whether the crop was the whole page, the main content or your own), the Sensitive Text panel used (how many finds and how they were hidden, never a find), a file opened or refused (a picture or a PDF, never its name or content), a preset saved, applied or deleted (never its name), the Assistant and the side panel used (whether a plan was proposed, run, undone or rejected and how many lines it had, never what you said), a setting changed, and the extension being installed or updated. Each carries a random id made on this browser, the extension's version, which browser it runs in (Chrome or Edge) and which store it came from. - **Off**, it stops every request before it is made, and the page your browser opens if you remove the extension no longer names the version, the browser or the store in its address. What is never sent: the address, title or content of a page, anything you type on a capture, a file name, anything the local agent connection carries, or a model's name, a server's port or a prompt you wrote. The capture itself, its marks and the files you export stay on your machine either way. The request goes from the extension's own code to Google's Measurement Protocol, with no Google script, no cookie and no added permission. The command line and the MCP server send nothing. A scan they ask for is counted once, by the extension. The [privacy policy](https://pagescanner.app/privacy/) lists every event and how long Google keeps them. ## Local Agents This is where you connect the extension to the command line or an MCP server on your own machine: **Connect**, **Connect through** (Page Scanner Helper, or a port and a token), **Group an agent's tabs** (a green tab group for the tabs an agent opens), and a name for this browser, plus the port and the token when you pair that way. When the connection fails, a toast says why, such as a helper that is not set up yet. [Local agents](https://docs.pagescanner.app/extension/local-agents) explains what that means and how to set it up. ## Where settings are kept In your browser's local storage, on this device. They are deliberately not synced through your Google account, so your settings, your captures and your pairing stay in this browser. --- # Local agents Let a script or an AI agent on your own machine ask the extension for a capture. The extension captures the page you are looking at when you click its icon. Two other things can ask it to capture a page instead: the `page-scanner` command, and an AI agent speaking MCP (the [Obsidian plugin](https://docs.pagescanner.app/obsidian) and the [Raycast extension](https://docs.pagescanner.app/raycast) run the command). Both are off until you connect them, and both go through the same connection. ## What they share - **The capture happens in a Chrome you are already signed in to.** A page behind a login is a page you are logged into, and no second browser is started. - **The connection stays on this computer.** Chrome starts Page Scanner's helper and talks to it directly, and the helper reaches the background process on `127.0.0.1`, never `0.0.0.0`. Nothing it carries leaves the machine. - **One setup per machine.** `npx @page-scanner/cli install` sets the helper up for every Chromium browser here, once. There is no port or token to copy. - **A background process does the work.** The command and the MCP server both talk to that one process, so you can use them at the same time, and the helper connects the extension to it. ## Which one you want **[The command line](https://docs.pagescanner.app/cli)** if you want to capture a page from a script, a Makefile or a terminal. `npx @page-scanner/cli scan --url
--out ` prints the path it wrote and nothing else. **[The MCP server](https://docs.pagescanner.app/mcp)** if you want an agent to do it: Claude Code, Claude Desktop, or anything else that speaks MCP. It is nine tools over the same connection. Installing both is fine. They share the setup and the background process. **[The agent skill](https://docs.pagescanner.app/mcp/skill)** goes with either. It tells the agent when Page Scanner is the right tool and how to use it well, and comes as a Claude Code plugin that also registers the server, or as a skill any agent can install with `npx skills add sbd530/page-scanner-skills`. ## Connect it 1. Run `npx @page-scanner/cli install`, or ask your agent to set up Page Scanner. It sets up the helper and says which browsers it found. 2. Open the extension's [settings](https://docs.pagescanner.app/extension/settings). Under **Local Agents**, give this browser a name and press **Connect**. Chrome asks once whether Page Scanner may "communicate with cooperating native applications", which is the helper; allow it. The same prompt asks to let Page Scanner manage tab groups: a page an agent asks for opens in a background tab inside a green **Page Scanner** group, so you can see which tabs it is working in, and the group goes away when the scan is done. Turn off **Group an agent's tabs** before pressing Connect if you would rather not allow that; the tab then opens without a group. The button is an icon: a plug and its socket, joining over and over while there is nothing connected. Once you have pressed it, it becomes **Disconnect**, the plug at rest, with **Reconnect now** (the circling arrows) beside it, which tries again at once rather than waiting for the next retry. The browser connects once a command or an agent is running. The first time, that can take up to a minute: Chrome gives the permission to a fresh start of the extension, not to the one already running, so leave the settings open, or reload Page Scanner on `chrome://extensions` to do it at once. If the connection fails, a toast says why, such as a helper that is not set up yet. Chrome runs a separate copy of the extension in every profile, so repeat step 2 in each profile you want reachable; your work profile and your personal profile are two browsers here. ### With a port and a token instead The way it worked before the helper, for a computer where it cannot be installed, and still working for every browser paired that way: run `npx @page-scanner/cli pair`, set **Connect through** to **A port and a token**, paste the port and the token it printed, and press **Connect**. The [MCP pairing guide](https://docs.pagescanner.app/mcp/pairing) covers checking and rotating a pairing. ## How an agent's scan differs from a click - **It always captures the whole page.** An agent has no preview to crop against. - **There is no raster fallback.** A click can fall back to scrolling and stitching when the debugger cannot attach; an agent's scan cannot, so it fails and says so instead of handing back an image. - **It follows the clean-up settings.** Ads, banners, chat widgets and pop-ups are hidden before an agent's capture too, unless the agent asks otherwise (`--hide` on the command line, `hide` for the MCP server). ## Off by default, and visible when on Connecting is a deliberate act: the extension ships with this off, and turning it on means pressing Connect and allowing Chrome's prompt, which no agent can do for you. While a scan runs, Chrome shows its own "started debugging this browser" bar, which no extension can hide, so a scan an agent started is never invisible. --- # Why the debugger Why a scan attaches Chrome's debugger to the tab, what the "started debugging this browser" bar means, and why it stays a few seconds after the scan. While a scan runs, Chrome shows a bar across the top of the window: ```text "Page Scanner: Full Page Screenshot" started debugging this browser ``` The bar is Chrome's, not Page Scanner's. Chrome shows it whenever an extension attaches its debugger to a tab, with that extension's name in the quotes, and Page Scanner attaches it for one reason: the debugger is the only way an extension can reach Chrome's own print-to-PDF, which is what keeps the PDF's text real text rather than a picture of text. ## What the debugger is for One attachment, one layout, two outputs. With the debugger attached, Page Scanner lays the page out once at its full height and takes two things from that one layout: a screenshot, which is the preview you crop in the editor, and Chrome's print-to-PDF, which is the file. Because both come from the same layout, the crop you draw on the preview lands exactly on the PDF, and the text in it stays selectable and searchable. Without the debugger, an extension can only scroll the page a screen at a time and stitch the screenshots together, which gives a picture of the text, not the text. ## How long the bar stays Page Scanner attaches the debugger to the one tab you scan when the scan starts, and detaches it the moment the scan is done. Chrome then keeps the bar up for about five more seconds before it takes it away. That delay is Chrome's own rule; no extension can shorten it, and Chrome does not tell an extension when the bar goes. It is why the bar is often still there as the editor opens. While it is, the editor says so in a small card by its toolbar, which goes when the bar goes. **Don't show again** on the card, or **Explain Chrome's debugging bar** in the [settings'](https://docs.pagescanner.app/extension/settings) Editor section, turns the card off. The bar's **Cancel** button detaches the debugger, which ends a scan that is still running. Scan again when you want the capture. When you [record steps](https://docs.pagescanner.app/extension/record-steps), the debugger stays attached to the one tab you recorded until you stop, so the bar is up the whole time. **Cancel** on the bar stops the recording, and the steps taken so far open as they would after **Stop**. ## What it does not mean Chrome's wording says "debugging this browser", and what happens is narrower than that. The debugger is attached to the one tab you scanned, for the length of that scan, and nothing else. Page Scanner asks for no host permissions, so it has no standing access to any site, and it does not watch the pages you have not scanned. The capture is not uploaded anywhere: it is kept in the extension's own storage in your browser so the editor can open it. Everything the extension keeps and sends is in the [privacy policy](https://pagescanner.app/privacy/). With [local agents](https://docs.pagescanner.app/extension/local-agents) connected, a program on your own computer can ask for a scan too. The debugger is still attached only for each scan, and Chrome shows the same bar for it. ## When the debugger cannot attach Only one debugger can attach to a tab at a time, so with DevTools open on the tab Page Scanner falls back to scrolling and stitching screenshots. The capture is then a picture: its PDF holds no selectable text, and the Output Format panel says so. Close DevTools and scan again for a capture whose text is text. ## Hiding the bar No extension can hide it. Chrome has a command-line switch that does, `--silent-debugger-extension-api`, which exists for automated test setups; Page Scanner does not ask you to use it, and with it the editor has no bar to speak of and shows no card. --- # Changelog Release notes for the Page Scanner extension, with new features, improvements and bug fixes by version. The version you have is on `chrome://extensions` (or `edge://extensions`), under Page Scanner. After an update, the next editor you open says so, with a button to this page. ## 2.2.0 October 24, 2026 - Added Scan scrolling in the popup, a preview: it scrolls the page by itself and makes a storyboard of how it behaves, the page cut into scenes with six frames each and what moved said in sentences. The editor plays it back in a flipbook, lets you mark the frames up, leave scenes out and write a note for each, and saves it as one PDF to hand to an AI coding agent - Added scroll storyboards for local agents: `page-scanner storyboard` and the MCP server's `storyboard_page` get the same PDF, what was measured as JSON and the frames as files ## 2.1.0 October 2, 2026 - Added Map this site in the popup, a preview: up to 30 of a site's pages captured whole and laid out on the editor's canvas by how many links they are from the start, with the links drawn between them, saved as one PNG, an SVG or a file for Figma - Added Record steps in the popup, a preview: each click becomes a step with a picture of the screen and a sentence that says it, sign-in and password fields are redacted, and the editor writes the guide as one PDF, a page a step - Added an accessibility check, switched on in the settings: the page's failures against WCAG A and AA boxed on the capture and listed in the editor's Accessibility panel, which saves the marked PDF - Added CSV to the Output Format panel, for the tables in the crop, including the ones a page draws with table roles or as a CSS grid - Added a welcome page after the install that says where the icon went, and a short tour of the editor the first time it opens - Improved Markdown and Word for discussion threads: comments, paragraphs and code stay apart, and a comment tree drawn by indentation keeps its depth - Improved Main content on pages whose main column sits beside a sidebar, such as GitHub issues - Improved the popup's buttons with an icon each - Fixed Markdown missing the text inside a shadow root and in code editors - Fixed very long and virtualized pages stopping short of their end, and chats that had not yet loaded their whole history - Fixed pages whose own print handlers changed the page while it was captured ## 2.0.0 September 29, 2026 - Added the AI Assistant (`Mod+K`), a panel in the editor that does what you ask in a sentence, in any language, with the editor's own controls: it lists what it would change, runs it on `Mod+Enter`, and Undo puts it back. It is a preview, read by Page Scanner's server, free for 10 requests a month - Added a side panel before the scan, opened from the button left of the popup's gear: say how the page should be captured (the width, the clutter to hide, folded sections, the color scheme, videos, one element), then approve it with Scan. The editor's Assistant carries on from what was said there - Added a phone width for the scan, and Phone screen pages for a PDF - Added the page's own citation data (author, date, publisher, address) to every file, with an optional RIS file for a reference manager, and an author or a date offered from the byline where the page declares none - Added extracting several tabs as a research bundle: a ZIP with a file and its Markdown for each tab, a references file, an index and SHA-256 digests - Added a note in every file when the browser machine-translated the page - Added the words in the page's pictures to the PDF's text, as canvases already were - Added the page's language to every PDF, detected where the page does not say it - Added ID and tax numbers found by their check digit to Pattern Scan, for Korea, Japan, China, Italy and the US - Added an offer of a model run in the browser, or a server on this computer, where AI scan and tidying find no built-in model - Added, for local agents: Markdown sized to fit a context, personal data taken out before an agent reads the page, slices of the page sized for a vision model, the page's pictures as files, and the passages an agent quoted highlighted in the PDF - Added a short survey on the page that opens when Page Scanner is removed - Changed the wordmark's typeface to Bricolage Grotesque - Removed Phone, tablet and desktop, the three widths side by side in one scan: a saved choice of it now scans at the phone width, and captures made with it still open - Fixed the color scheme choice on pages that switch their theme with a class - Fixed AI scan and tidying reaching for a model that has to download first while offline ## 1.3.2 September 26, 2026 - Added a background for the frame's padding: a color, eight gradients, ten wallpapers made for Page Scanner, or a picture of your own - Added Find in the capture (`Mod+F`), which searches the capture's text and steps through every hit - Added a choice of AI model in the settings: Chrome's built-in one, a model served on this computer (Ollama, LM Studio, llama.cpp and others), or a model run in the browser - Added editing AI scan's prompts, per kind, with a way back to the default - Added Remove element (`D`), a prototype tool that scans the page again without the elements you point at - Added `Mod+P` to extract, `Mod+1` to `Mod+6` to open the rail's panels and `Mod+B` to fold the panel, with each shortcut shown on its button while `Mod` is held - Added a note in the editor after an update, with a link to this changelog - Added a trash button beside each find in Sensitive Text, to take it off the list - Changed Sensitive Text to look for nothing until a scan is pressed, with Pattern Scan, Custom Pattern and AI Scan each a button of its own - Changed the stage's right-click menu to leave out what cannot be done right now - Fixed the editor's keys not answering on a keyboard that types no Latin letters, such as Korean - Fixed an editor left open putting its output choices back over the ones made in another - Fixed a colored padding showing through the white parts of a page in the PDF - Fixed two of the toolbar's menus staying open at once ## 1.3.1 September 25, 2026 - Added Microsoft Edge support: Page Scanner is listed on Edge Add-ons, and says Edge wherever it talks about the browser - Added Page Scanner Helper support to the Edge build, so local agents connect there too ## 1.3.0 September 24, 2026 - Added a new editor layout: floating islands, a grouped toolbar centered on the stage, and no header - Added a rail on the right for the editor's panels, with Help, the theme and the settings at its foot - Added a Presets panel to the rail - Added a right-click menu on the stage - Added `Mod+C` to copy the crop - Added W and H fields to the Frame panel, to size the crop exactly - Added crop guides with a choice of grid, switched on from the Frame panel - Added a dot grid to the canvas, and a choice of canvas gray - Added Erase text (`W`), which takes words out of the capture as if they had been deleted - Added opening a PDF from disk in the editor, as its own pages - Added opening an image from disk in the editor, with Find sensitive text working on pictures - Added a clean-up before capture that hides ads, consent banners, chat widgets and pop-ups, on by default, with a toast that says what was hidden - Added the design extract: a page's design as tokens, an audit and a contrast check, a site's pages found by following its links, and its components drawn in a vector catalog - Added tidying of Markdown and Word exports with Chrome's built-in model, on this computer - Added connecting local agents through Page Scanner Helper, with no port or token to paste - Added a green Page Scanner tab group for the tabs an agent opens - Added a card by the toolbar that explains Chrome's debugging bar, and a [page on why it appears](https://docs.pagescanner.app/extension/debugger) - Added the page's favicon and title to the popup's header - Added a scan animation to the popup, which now stays open while a scan runs - Changed Extract to a round button over the stage that goes straight to a file - Changed the settings to a dialog over the editor, opening on Appearance - Changed the popup's page width to a select, and set the scan apart from Pick an element with "Or" - Changed the output choices to one line each, with hints on hover - Changed the window frame on the stage to draw the way the file draws it, in the Windows 11 style - Changed remembering the editor's last choices to follow a setting - Changed the extension's name back to Page Scanner alone, with a new summary in five languages - Changed a bridge failure to show as a toast - Fixed the move cursor showing over a crop that covers the whole page - Fixed Extract changing width while it builds - Fixed the popup, the editor and the settings showing a light frame before painting dark - Fixed pdf.js warnings appearing on the extension's Errors page - Fixed an agent's tab timing out after it was grouped - Fixed Connect needing a reload before it used the helper ## 1.2.0 September 23, 2026 - Added Word export of the crop's text - Added Markdown export of the crop's text - Added PDF/A-2b export, for archiving - Added an integrity record written beside an export, and a way to verify it - Added scanning several selected tabs into one document - Added the page as Markdown beside the file, for agents - Added annotation text set in the captured page's own fonts, as real text in the PDF - Added Korean, Japanese and Chinese annotation text, placed in the PDF as a picture with its words - Changed the popup's element picker to a button, **Pick an element** - Changed the tool palette to open folded, and slide open from a pencil - Changed export file names to keep the letters of any script - Changed the formats agents can ask for to PDF, PNG and JPEG - Fixed Chrome crashing on long pages, which are now captured whole - Fixed a white band at the bottom of some previews - Fixed pages on a 2x screen printing differently from how they showed - Fixed pages with a nonce-only `style-src` moving during the capture ## 1.1.0 September 23, 2026 - Added a logo, a name and a watermark on the output - Added text recognition for the pictures in a capture, run on this computer, so their words are in the PDF - Added links in the PDF, kept from the page - Added PDF bookmarks from the page's headings - Added capture of pages taller than 60,000 px, printed in exact bands and joined - Added capture at a phone's, a tablet's and a desktop's width in one scan - Added opening what a page keeps folded before the capture, and folding it back after - Added picking one element on the page, which opens the editor cropped to it - Added Find sensitive text, which offers sensitive text in the crop for redaction - Added cutting a band out of the output, with the text past the crop kept out of the PDF - Added numbered steps and a close-up on the capture - Added named presets for the editor's choices - Added a macOS or Windows title bar around the output - Added usage statistics that count which features are used, with a switch in the settings' Privacy section - Changed the editor to open with the crop on the page's main content - Fixed a page too tall for 2 % zoom not fitting on the stage - Fixed pages written with `light-dark()` printing in the wrong color scheme - Fixed a text selection in an article dropping when the pointer was between paragraphs - Fixed the empty side of the palette column blocking clicks - Fixed a sticky table-of-contents heading turning up in the bookmarks ## 1.0.0 September 22, 2026 - Added rectangles, ellipses, lines and arrows - Added a highlighter that multiplies into the page - Added text on the capture, kept as text in the PDF - Added emoji stamps - Added blur and redaction: the text under a redaction is removed from the PDF, and the text under a blur is rewritten, so an extractor cannot read either - Added selecting text by dragging across it, for the highlighter, the blur and the redaction - Added padding and a border around the output - Added the source URL and the capture time, stamped on the output - Added paper page breaks placed where the page is quiet, not where the ruler falls - Added capture at a sheet's width, chosen in the popup before the scan - Added capture in the color scheme the page is showing, or one you choose - Added a panel beside the stage for what shapes the file - Added remembering the last marks style and output choices between captures, with a reset - Added offering the page again when the popup opens over its editor - Changed toasts to show their status by color, with a close button - Fixed the page zooming to double size on a 1x display while a scan runs - Removed the small-print caution, which showed on almost every capture ## 0.3.1 September 13, 2026 - Changed the extension to a new design system - Changed pairing to point at the new `page-scanner` command line - Added the wordmark to the canvas - Improved the crop guides' contrast on a white page in light mode ## 0.3.0 September 12, 2026 - Added US Letter - Added printed-sheet margins to the PDF's pages - Added a notice when a capture stopped at the size ceiling - Changed the default PDF page size to A4 - Changed the page sizes to say what each one does ## 0.2.1 September 4, 2026 - Changed the extension's description ## 0.2.0 September 4, 2026 - Added a local bridge, so an AI agent can run a scan over MCP - Added the sheet cuts, drawn on the stage while Extract is open - Fixed boxes sized to the window stretching when the page is laid out at its full height ## 0.1.1 August 24, 2026 - Fixed capture of app shells that scroll a nested box instead of the page ## 0.1.0 August 23, 2026 - Initial release: full-page capture to a PDF whose text is still text, and to PNG and JPEG, with a crop, zoom, actual size and copy to the clipboard --- # The page-scanner command Capture a whole web page from a terminal, through the Chrome you already use. ```bash npx @page-scanner/cli install npx @page-scanner/cli scan --url https://en.wikipedia.org/wiki/PDF --out ./pdf.pdf ``` The second line prints one thing on stdout, the absolute path of the file it wrote, so it drops into a pipeline without parsing. The capture is done by the Page Scanner extension in your own Chrome, which is what makes a logged-in page capturable. This package is the other half: it listens on loopback for that extension, and turns `scan` into a file. ## Next - [Install it](https://docs.pagescanner.app/cli/install), two ways. - [Every command](https://docs.pagescanner.app/cli/commands), with the output contract and the exit codes. - [Watch a page for changes](https://docs.pagescanner.app/cli/watch), with a script cron or launchd runs. --- # Install npx, or a global install. ```text Set up the Page Scanner command line on this computer, so you can capture web pages through my Chrome. The install guide is https://docs.pagescanner.app/cli/install.md; every page of the documentation at https://docs.pagescanner.app is also Markdown at its address plus .md. 1. Run `node --version`. Page Scanner needs Node.js 24 or newer; if it is older or missing, stop and tell me. 2. Run `npm install -g @page-scanner/cli`. 3. Run `page-scanner install`. It sets up the helper Chrome starts to reach Page Scanner, for every Chromium browser on this computer, and prints which. It returns no secret. 4. Then ask me to do the part only I can do, in Chrome, and wait until I say it is done: - install the Page Scanner extension if I have not, from https://chromewebstore.google.com/detail/page-scanner/oinkohacnbkapdnnhpidmoidmidlgaoj?utm_source=docs.pagescanner.app (or https://microsoftedge.microsoft.com/addons/detail/edlmbcahnbpdfibbimdkdbgiemadanhh?utm_source=docs.pagescanner.app in Edge); - open its settings, and under Local Agents give this browser a name, press Connect and allow Chrome's prompt. 5. Run `page-scanner browsers` to check. The first connection can take up to a minute, so if nothing is listed, wait and run it again before you tell me it failed. 6. Ask me whether to add the Page Scanner agent skill, which teaches you when and how to use the command: `npx skills add sbd530/page-scanner-skills`. Do not run `page-scanner pair` unless I ask for it: it prints a pairing token into this conversation, and the helper needs none. When it works, tell me which browsers are connected. ``` Or do it yourself, as follows. ## Requirements - Node.js 24 or newer. - Google Chrome, or another Chromium browser, with the Page Scanner extension 1.3.0 or newer installed. Earlier versions have no helper to connect through, no `--hide` and no `design`. ## Two ways ```bash npx @page-scanner/cli --help # no install npm install -g @page-scanner/cli # then just `page-scanner` ``` ## Set it up Once per machine: ```bash page-scanner install ``` It sets up Page Scanner's helper for every Chromium browser it finds and says which. Open the Page Scanner settings in Chrome, go to **Local Agents**, name the browser, press **Connect**, and allow Chrome's prompt. There is no port or token to copy: Chrome starts the helper for the Page Scanner extension, and the helper reads the pairing `install` saved in `~/.page-scanner/`. The same prompt asks to let Page Scanner manage tab groups, so a page a command opens sits in a green **Page Scanner** group while it is scanned; turn off **Group an agent's tabs** first if you would rather not allow it. The first connection can take up to a minute, because Chrome gives the permission to a fresh start of the extension. Leave the settings open, or reload Page Scanner on `chrome://extensions` to do it at once. Chrome runs a separate copy of the extension in every profile, so your work profile and your personal profile are two different browsers here. Naming them is how you tell them apart later. Run it again after installing another browser. `page-scanner uninstall` takes the helper out of every browser. An unpacked build of the extension, loaded in developer mode, is found in the browser's profiles and allowed as well, so there is no id to look up; `--extension-id ` adds one by hand, and `--browser-dir ` sets up only a profile started with `--user-data-dir`. The helper runs on the Node that ran `install`, named by its full path, because Chrome starts it without your shell's `PATH`. If that Node goes away (a version manager switched, or Homebrew upgraded it), `page-scanner status` says so and the helper stops connecting; run `install` again. `--node /opt/homebrew/bin/node` names a path that follows Homebrew's upgrades instead. ### With a port and a token instead For a machine where the helper cannot be installed: `page-scanner pair` prints a port and a token and saves them to `~/.page-scanner/config.json`. In **Local Agents**, set **Connect through** to **A port and a token**, paste both, name the browser, and press **Connect**. `pair` waits up to two minutes and tells you when the browser arrives. ## Updating `npx @page-scanner/cli` asks npm for the newest version each time it runs, and installs it when it is newer, so there is nothing to update. A global install stays on the version it installed, and while it is there `npx` runs that copy too: ```bash npm install -g @page-scanner/cli@latest ``` The next command that finds the old daemon still running shuts it down and starts its own. The pairing in `~/.page-scanner/config.json` carries over, and the extension reconnects by itself, so nothing needs pairing again. If you also use the MCP server, keep the two on the same version. A command replaces a daemon of any other version, or of another build of the same version (which happens when the CLI is built from source), so two versions on one machine keep replacing each other's daemon, and the browser drops its connection each time. A command does not replace one in the middle of a capture: it waits up to two minutes for the capture to end, and a daemon from 0.3.6 on that an older command asks to stop finishes its captures first. --- # Commands The whole surface, what each one prints, and what it exits with. ``` page-scanner install [--extension-id ]... [--browser-dir ]... [--node ] [--json] page-scanner uninstall [--browser-dir ]... [--json] page-scanner pair [--port ] [--rotate] [--wait =120] [--no-wait] [--json] page-scanner status [--json] page-scanner browsers [--json] page-scanner tabs [--browser ] [--wait =30] [--json] page-scanner scan (--url ... | --urls | --tab ) [--window ] [--name