Delete Pages from PDF — Remove Unwanted PDF Pages Online

Blank sheets after scanning, a service page in the middle of a report, an extra appendix in a contract — you often just need to throw a few pages out of a PDF. The "Delete Pages" tool in pdfredX removes them visually: you see all the pages as thumbnails, mark the unwanted ones and get a document without them. All in the browser, nothing uploaded to a server.

Step 01. Upload the PDF

Open pdfredx.com and add the document. PDF.js renders each page into a thumbnail, and the whole file lays out as a gallery of cards. Not a single byte goes to a remote machine.

Step 02. Mark the pages to delete

Turn on selection mode and click the thumbnails of unwanted or blank pages — they get marked. You can see how many are selected. Press "Delete" — the marked sheets are removed from the document.

• A quick way for a single page — the 🗑 button right on a card deletes it at once, without selection mode.
• Made a mistake — before deleting, just unmark it with another click.

Step 03. Save the document without the extra pages

Press "Create PDF". The app assembles the file from only the remaining pages — the deleted ones don't make it in. The finished "cleaned" PDF downloads straight from the browser. Free, no registration, no server queue.

How it works under the hood

All pages live in a single items[] array. Deletion is a filter over the array: the marked pages are excluded in one items.filter(...) operation, and the gallery redraws. On export jsPDF walks only the remaining elements and assembles a new document from them. So the deleted pages are physically absent from the final file — this is not "hiding" but a rebuild without them.

Known limitations

Deletion by page boundaries. The tool removes whole sheets. Cutting a fragment within a page is a different task.

The export result is raster. The remaining pages are inserted as images, so the text in the final file can't be selected, and hyperlinks and bookmarks are not carried over. The deletion itself doesn't affect this — it's a property of the export.

Undo is before saving. Until you press "Create PDF", you can change the order and set of pages freely; after export, edit the source, not the downloaded file.

Need to rearrange pages rather than delete them? That is the Reorder Pages tool. And to cut a document into parts — Split PDF.

Try it right now — pdfredx.com, no registration, your files stay with you.

Before forwarding a contract, a report or a statement, you often need to remove a couple of pages from the document: an appendix with personal data, an internal service page, a sheet with bank details the recipient doesn't need to see. And here a contradiction arises: you delete pages precisely for confidentiality — yet an ordinary online service asks you to upload the whole document, including those pages, to its server. Let's look at how to cut out sheets locally and why it is genuinely permanent.

The paradox of server-side deletion

You want the confidential pages not to travel any further. Yet to "delete page 5," a server service receives all the pages, including the very one you're hiding. From there the uploaded file lives by the service's policy, which few people ever read:

• it is stored in a contractor's temporary storage (AWS, GCP, Azure);
• it is processed on someone else's server;
• it is kept from a few hours to several days "for reliability";
• it is logged together with metadata — IP, time, file name.

So the page you deleted for privacy still makes it to someone else's machine anyway.

Local deletion: the document never leaves the tab, and the pages truly disappear

pdfredX removes pages without uploading the file anywhere — and does it so that the deleted sheet is nowhere in the final file.

The file is read locally. PDF.js opens the document in the tab; there is no network request carrying it.

Deletion happens in the tab's memory. The marked pages are excluded from the working array; nothing is sent anywhere.

The final file is assembled anew — from only the remaining pages. This is the key point: the export doesn't "hide" pages or mark them as hidden, it rebuilds the PDF from the ones that are left. The content of the deleted sheets is physically absent from the new file — neither as text nor in metadata.

It works offline. Load the document, turn off the internet and remove the pages — everything keeps working. The network is only needed to load the app once.

In practice: mark the confidential sheets (or delete them with the 🗑 button), press "Create PDF" — you get a cleaned document, and everything extra stays only with you.

What we cannot guarantee — an honest disclaimer

Client-side processing protects a document from being sent to external servers, but it is not a shield against every threat.

Malware or a keylogger on the device. If the machine is compromised, a program can read files off the disk bypassing the browser entirely.

Browser extensions with broad permissions. An extension with "read data on all sites" access can, in theory, see the tab's contents. For sensitive documents, work in a profile without third-party extensions or in a private window.

The source file stays with you. The deletion applies to the new document; the original with the full set of pages still sits on your disk — keep or delete it at your discretion.

We provide isolation at the level of the browser tab. The rest is on the user's side.

Cut out the extra pages without uploading the document to a server — pdfredx.com, free, no registration.

Deleting a page from a PDF on a server can be done "by the book": parse the structure, find the node in the page tree (Page Tree), remove the reference to it, rewrite the cross-reference table. In the browser, within the app's shared raster pipeline, it's arranged more simply and reliably. Let's break down how the delpages tool in pdfredX is built: why deletion is an array filter, why the deleted content truly disappears, and where the boundaries of the approach run.

The architectural choice: editing the Page Tree vs. filtering an array

Editing the structure (Page Tree). The "server" way is to modify the page tree in the PDF structure without rasterizing the content: the page keeps its vector form. But it requires a PDF parser, careful work with objects and the xref, and on files with a non-standard structure the stability drops.

Filtering the array (the pdfredX path). A page of any document is already reduced to an image: PDF.js drew it at load time into the items[] array. So deletion doesn't touch the PDF structure — it simply excludes elements from the array, and the final file is assembled anew from the remaining ones. The upsides are predictability and privacy (everything in the tab); the price is a raster result.

The implementation, piece by piece

Selecting pages: a set of marks

In deletion mode, a click on a thumbnail adds or removes its id in a Set of marks:

if (selectedIds.has(id)) selectedIds.delete(id);
else                     selectedIds.add(id);

Until the user confirms, nothing is deleted — the marks are fully reversible.

Deletion: a single filter operation

Confirmation excludes the marked pages in one pass over the array:

function deleteSelected() {
  if (!selectedIds.size) return;
  items = items.filter(function(p) { return !selectedIds.has(p.id); });  // keep the unmarked
  selectMode = false; selectContext = null; selectedIds.clear();
  render();
}

The 🗑 button on a card is the same principle for a single page (delItem(id)), without entering selection mode. items[] remains the single source of truth about the document's makeup.

Rebuild: jsPDF over what remains

The key point for "permanence": the export doesn't mark pages as hidden, it builds a new PDF from only the remaining items[] elements — the same way as merging and splitting (an A4 sheet, orientation by proportions, contain). The deleted pages take no part in the assembly, so their content is not in the final file — no pixels, no text, no metadata.

Trade-offs and the limits of the approach

Deletion only by page boundaries. A whole sheet is removed; this mechanism can't cut a fragment within a page.

A raster result. The remaining pages are images: the text in the final file can't be selected, and links and bookmarks are not carried over. That's the price of the raster path, not of the deletion.

Reversibility is before export. Marks and the set of pages change freely until assembly is triggered; after export, edits go to the source.

What's next

Selection inversion — "keep only the marked" instead of "delete the marked" (overlaps with page extraction).

Optional structural deletion for purely digital PDFs — a branch through editing the Page Tree, to preserve text and links on the remaining pages when the source allows it.

Want to test it — load a multi-page PDF on pdfredx.com, mark the extra sheets and assemble the document. No registration, no file upload to a server.