Add Watermark to PDF — Free Document Protection Online

A draft needs to be marked "DRAFT," a proposal marked "COPY," a mockup stamped with the company logo across the whole area. The "Watermark" tool in pdfredX applies a text or image mark to every page of the document right in the browser: you set the look in a live preview and download the marked PDF. Nothing is uploaded to a server.

Step 01. Load the PDF

Open pdfredx.com and drag a PDF into the drop area — or pick it through your file browser. PDF.js renders the pages inside the tab. Not a single byte goes to a remote machine.

Step 02. Configure the watermark

A window opens with a live A4 preview — every change is shown at once. Two modes are available:

• Text. Enter your caption (default "Confidential"). Color, transparency, size, font, bold and italic are adjustable.
• Logo. Upload an image (for example, a PNG logo) — size and rotation angle are adjustable.

Placement is chosen with buttons:

• 9 positions — corners, edge centers and the middle of the page.
• Diagonal — a large caption across the whole page at an angle.
• ☑ Tile — the caption repeats in a grid over the whole area at a −35° angle; this continuous pattern is the hardest to remove and best protects against copying.

Transparency (opacity) sets how much the mark "shows through": 15–30% doesn't get in the way of reading the document, yet the mark stays visible.

Step 03. Save the protected PDF

Press "Apply" — the mark is placed on all pages at once, and the preview shows in the gallery. Then "Create PDF" assembles the finished file. The watermark is baked into every page, and the download goes straight from the browser. Free, no registration, no server queue.

How it works under the hood

The mark is drawn on canvas over the page image. Depending on the mode, the drawWatermarkOnCanvas function either lays out text (fillText with the chosen font, color and globalAlpha = transparency) or overlays an image (drawImage with rotation). For "tile" mode the caption repeats in a 5×3 grid, each cell rotated by −35°; for "diagonal" — a single large caption along the page's diagonal.

The finished mark is "imprinted" into the page through applyWatermarkToDataUrl: the original is drawn onto a canvas, the watermark on top, and the result is exported back to an image. That way the mark becomes part of the page, not a separate layer.

Known limitations

The mark becomes part of the page. That is a plus for protection (the mark can't be selected or deleted as an object), but there is no "remove the mark from the finished file" button — apply it to a copy and keep the original separately.

Uniform settings for the whole document. The watermark is applied to all pages identically. Different marks on different pages are not yet supported.

The result is raster. Pages are exported as images, so the document's own text can't be selected in the finished file (that is a general property of the export, not just of the watermark).

Need to lock the document with a password, not just mark it? That is the Protect PDF with a password tool.

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

You send a mockup to a client, a draft for review, a portfolio in response to a job posting. And you want the document not to be used behind your back: your draft not passed off as final, your photos not resold, the "COPY" mark not removed. The usual problem with such marks is that they're too easy to strip: if the watermark sits as a separate text layer, it's deleted in a couple of clicks in an editor. Let's look at how to make the mark sturdy and why it's worth applying locally.

Why an ordinary watermark comes off easily

Many tools add a watermark as a separate object — a text layer or an annotation over the page. It looks fine, but the protection is illusory: the recipient opens the file in an editor, selects that layer and deletes it. The mark disappears, the document stays clean.

A sturdy mark has to be fused into the page itself, not lie on top as a separate element — only then can it not be selected and deleted as an object.

How pdfredX makes the mark inseparable

pdfredX doesn't overlay the mark as a separate layer — it bakes it right into the page image. Each page is drawn on canvas, the watermark is applied on top, and the result becomes a single raster: the mark's letters and the page content are now the same pixels.

• No separate layer — nothing to select. In the finished file the watermark isn't an object; you can't remove it in an ordinary editor with one click.
• Tile mode strengthens protection. A caption repeated in a grid across the whole page at an angle overlaps the content so that cutting it out without damaging the document is extremely hard.
• Transparency on your side. 15–30% is enough for the mark to read without getting in the way of the document.

> Honestly about the limits: no visual watermark protects 100%. A sufficiently motivated person can paint over the mark in an image editor or re-shoot the screen. Baking into the raster raises the bar — you can no longer strip the mark "in two clicks" — but it doesn't make it absolutely unremovable. For legally meaningful authorship protection, use a watermark together with other measures (password, publication with a fixed date).

Why the mark should be applied locally

Here lies the contradiction of server-side services. You add a watermark in order to control the document — yet an ordinary online service asks you to first upload that document to its server. That is, the unprotected original (a draft, a mockup, a photo without a mark) first travels to someone else's machine, and only there does the mark get applied.

pdfredX applies the mark without uploading the file anywhere:

• The file is read locally — PDF.js opens it in the tab, there is no network request carrying the document.
• The mark is applied in the tab's memory — canvas drawing and assembly run over data that is already loaded.
• Only the finished marked file is downloaded — the unmarked original goes nowhere.
• It works offline — the network is only needed to load the app once.

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 saved file stays on your disk. If the device is not protected by encryption, files can be read by third parties with physical access.

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

Put a sturdy watermark without uploading the document to a server — pdfredx.com, free, no registration.

You can watermark a PDF in different ways. The classic server-side path is to add a vector text layer into the PDF structure through a library like pdf-lib, controlling transparency and the rotation matrix at the level of graphics operators. Such a layer stays sharp at any scale, but it remains a separate object — and therefore potentially removable. In the browser, within the app's shared raster pipeline, a different path is chosen. Let's break down how the watermark tool in pdfredX is built: why canvas rendering instead of a vector layer, how the "tile" and "diagonal" modes work, and why the mark is baked into the page.

The architectural choice: a vector layer vs. canvas rasterization

A vector layer (pdf-lib). Added into the PDF structure as separate content: text with a set transparency and rotation. The plus is scalability and small size. The minus for a protection task is that it's still an object over the page, one that can be selected and deleted in an editor.

Canvas rasterization (the pdfredX path). The tool is built into the pipeline where a page is already reduced to an image (PDF.js drew it at load time). The watermark is drawn with the same Canvas 2D API over that image and fused with it into a single raster. The price is the loss of the mark's vector sharpness; the gain is that the mark can't be detached from the content (it's the same pixels), and rendering is predictable, including Cyrillic (a frequent problem when inserting fonts into a PDF programmatically).

The implementation, piece by piece

A single drawing function

All the mark's geometry is drawn by drawWatermarkOnCanvas(ctx, w, h, settings). Transparency is set once via globalAlpha, then it's by mode:

ctx.globalAlpha = settings.opacity / 100;
// image mode: scale from width, rotation, 9 anchor positions
// text mode: fillText with the chosen font/color, three layouts below

Font size is from the page, not in pixels. So the mark looks the same on pages of different resolution, the size is computed from the smaller side: fontSize = round(min(w,h) * sizePC/100). That way the mark scales together with the page.

Three text layouts

if (tile) {
  const rad = -35 * Math.PI / 180;           // the pattern's tilt
  for (let row = 0; row < 5; row++)
    for (let col = 0; col < 3; col++) {       // a 5×3 grid over the whole area
      ctx.translate(w*(col+0.5)/3, h*(row+0.5)/5);
      ctx.rotate(rad); ctx.fillText(text, 0, 0);
    }
} else if (pos === 'diagonal') {
  const angle = -Math.atan2(h, w);            // exactly along the sheet's diagonal
  ctx.translate(w/2, h/2); ctx.rotate(angle);
  ctx.fillText(text, 0, 0);
} else {
  // 9 anchor positions: corners/edge centers/middle + margins
}

• Tile — 15 repeats of the caption in a 5×3 grid, each at −35°: a continuous coverage that is hardest to remove.
• Diagonal — the angle is taken as -atan2(h, w), so the caption lies exactly along the diagonal of that particular sheet (for A4 portrait and landscape the angle differs).
• 9 positions — anchors with a min(w,h)*0.06 margin, the text alignment adapting to the angle (right/left/center).

Baking into the page

applyWatermarkToDataUrl turns the mark into an inseparable part of the page:

const c = document.createElement('canvas');
c.width = origW; c.height = origH;
const ctx = c.getContext('2d');
ctx.drawImage(img, 0, 0, origW, origH);      // the page itself
drawWatermarkOnCanvas(ctx, origW, origH, wmSettings); // the mark on top
ok(c.toDataURL('image/jpeg', 0.92));         // a single raster

The key point is that the mark is drawn at the page's native resolution (origW/origH), not at the preview size, so it doesn't blur on export. The result is a single JPEG: the content and the mark are now inseparable. The same call is used during compression too (wmApplied), so the mark isn't lost after compression.

The live preview

renderWmPreview draws the same drawWatermarkOnCanvas on a small #WM_PREVIEW canvas over "fake" lines of text — the user sees the result before applying it to the real pages, without reassembling the file.

Trade-offs and the limits of the approach

The mark is raster. There is no vector sharpness at strong zoom — but for an on-screen document and printing the difference is barely visible, and inseparability matters more.

Uniform settings for the document. wmSettings is one for all pages; different per-page marks are not yet supported.

Not cryptographic protection. Baking raises the bar for "strip in two clicks," but a motivated person can paint over the mark in an image editor. A watermark is deterrence and attribution, not encryption.

What's next

Per-page marks — different marks or numbering on specific pages (overlaps with the numbering tool).

Export preserving a vector layer for purely digital PDFs — an optional branch through structural insertion, when scalability matters more than inseparability.

Want to test it on your own document — load a PDF on pdfredx.com, configure the mark in the preview and download the marked file. No registration, no file upload to a server.