Add Watermarks to Images: Best Practices for Brand Protection

Watermarking is the practice of overlaying a semi-transparent text, logo, or pattern onto an image to assert ownership, prevent unauthorized use, and promote brand recognition. Whether you're a photographer sharing portfolios online, a designer showcasing mockups, or a business protecting product images, adding watermarks is an essential step in content protection.

Why Watermark?

• Deter theft — A visible watermark makes images less attractive for unauthorized use
• Brand promotion — Watermarked images spread your brand when shared
• Copyright notice — Establishes legal ownership in case of infringement
• Tracking — Different watermarks can identify which client or platform leaked an image
• Preview protection — Watermark draft work before the client pays

Watermark Types

Text Watermarks

A text overlay with your name, brand, or copyright notice:

© Jane Doe Photography 2025

Best for: photographers, freelancers, content creators

Logo Watermarks

A semi-transparent version of your logo placed on the image:

Best for: businesses, agencies, established brands

Pattern / Tiled Watermarks

Repeated text or logo across the entire image, making removal nearly impossible:

©  ©  ©  ©  ©  ©
©  ©  ©  ©  ©  ©
©  ©  ©  ©  ©  ©

Best for: high-value stock images, legal documents

Online Watermark Tool

The Image Watermark tool on Help2Code lets you add both text and image watermarks directly in your browser — no upload required, everything runs locally.

Features

• Text watermark — custom text, font, color, size, opacity, rotation
• Image watermark — upload a logo or signature as the watermark overlay
• Position presets — center, top-left, top-right, bottom-left, bottom-right, or custom
• Tiling — repeat the watermark across the entire image
• Opacity control — adjust transparency from 1% to 100%
• Output formats — PNG, JPEG, WebP
• 100% client-side — your images never leave your device

How to Use

1. Drop an image or click to browse
2. Choose text or image watermark mode
3. Enter your text or upload a logo
4. Adjust position, opacity, size, and rotation
5. Enable tiling if desired
6. Click download to save the watermarked image

Watermark Placement Strategies

Recommendation: Use a bottom-right text watermark at 40-60% opacity for general protection. For high-value content, combine corner placement with a semi-transparent tiled background.

Best Practices

Opacity

• 30-50%: Subtle but visible — good for portfolios and social media
• 50-70%: Clear visibility — good for previews and drafts
• 70-100%: Strong presence — use when theft is a serious concern

Size

The watermark should be large enough that cropping it out would ruin the image, but not so large that it obscures the content. A good rule is 5-10% of the image width for text, or 10-20% for logos.

Color

• White with drop shadow works on most images
• Black with white outline for light backgrounds
• Match your brand color for consistency

Font Choice

• Sans-serif fonts (Arial, Helvetica) are most readable at small sizes
• Avoid thin or decorative fonts that disappear at low opacity
• Bold weight ensures visibility

Programmatic Watermarking

Python: Add Text Watermark with Pillow

from PIL import Image, ImageDraw, ImageFont

def add_text_watermark(
    input_path: str,
    output_path: str,
    text: str,
    opacity: int = 60,
    position: str = 'bottom-right'
):
    with Image.open(input_path).convert('RGBA') as img:
        watermark = Image.new('RGBA', img.size, (0, 0, 0, 0))
        draw = ImageDraw.Draw(watermark)
        font = ImageFont.truetype('arial.ttf', int(img.width * 0.05))

        bbox = draw.textbbox((0, 0), text, font=font)
        tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]

        positions = {
            'top-left': (20, 20),
            'top-right': (img.width - tw - 20, 20),
            'bottom-left': (20, img.height - th - 20),
            'bottom-right': (img.width - tw - 20, img.height - th - 20),
            'center': ((img.width - tw) // 2, (img.height - th) // 2),
        }

        x, y = positions.get(position, positions['bottom-right'])
        alpha = int(255 * opacity / 100)
        draw.text((x, y), text, font=font, fill=(255, 255, 255, alpha))
        watermarked = Image.alpha_composite(img, watermark)
        watermarked = watermarked.convert('RGB')
        watermarked.save(output_path, quality=95)

add_text_watermark('photo.jpg', 'watermarked.jpg', '© Jane Doe')

Python: Add Logo Watermark

from PIL import Image

def add_logo_watermark(
    input_path: str,
    output_path: str,
    logo_path: str,
    opacity: int = 50,
    position: str = 'bottom-right',
    scale: float = 0.15  # 15% of image width
):
    with Image.open(input_path).convert('RGBA') as img, \
         Image.open(logo_path).convert('RGBA') as logo:

        new_width = int(img.width * scale)
        ratio = new_width / logo.width
        new_height = int(logo.height * ratio)
        logo = logo.resize((new_width, new_height), Image.LANCZOS)

        logo_with_alpha = Image.new('RGBA', logo.size, (0, 0, 0, 0))
        for x in range(logo.width):
            for y in range(logo.height):
                r, g, b, a = logo.getpixel((x, y))
                logo_with_alpha.putpixel((x, y), (r, g, b, int(a * opacity / 100)))

        positions = {
            'top-left': (20, 20),
            'top-right': (img.width - new_width - 20, 20),
            'bottom-left': (20, img.height - new_height - 20),
            'bottom-right': (img.width - new_width - 20, img.height - new_height - 20),
            'center': ((img.width - new_width) // 2, (img.height - new_height) // 2),
        }

        x, y = positions.get(position, positions['bottom-right'])
        img.paste(logo_with_alpha, (x, y), logo_with_alpha)
        img.convert('RGB').save(output_path, quality=95)

add_logo_watermark('photo.jpg', 'logo-marked.jpg', 'logo.png')

JavaScript (Node.js): Watermark with Sharp

const sharp = require('sharp');

async function addWatermark(input, output, text) {
  const metadata = await sharp(input).metadata();
  const svgText = `
    <svg width="${metadata.width}" height="${metadata.height}">
      <style>
        .text { fill: white; font-size: ${metadata.width * 0.04}px;
                font-family: Arial; font-weight: bold; opacity: 0.5; }
      </style>
      <text x="${metadata.width - 20}" y="${metadata.height - 20}"
            text-anchor="end" class="text">${text}</text>
    </svg>
  `;

  await sharp(input)
    .composite([{ input: Buffer.from(svgText), top: 0, left: 0 }])
    .toFile(output);
}

addWatermark('photo.jpg', 'watermarked.jpg', '© Jane Doe');

PHP: Watermark with GD

function addWatermark(string $input, string $output, string $text): void {
    $img = imagecreatefromstring(file_get_contents($input));
    $w = imagesx($img);
    $h = imagesy($img);

    $fontSize = intval($w * 0.04);
    $fontFile = '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf';
    $color = imagecolorallocatealpha($img, 255, 255, 255, 80);

    $bbox = imagettfbbox($fontSize, 0, $fontFile, $text);
    $tw = $bbox[2] - $bbox[0];
    $th = $bbox[1] - $bbox[7];
    $x = $w - $tw - 20;
    $y = $h - $th - 20;

    imagettftext($img, $fontSize, 0, $x, $y, $color, $fontFile, $text);
    imagejpeg($img, $output, 95);
    imagedestroy($img);
}

addWatermark('photo.jpg', 'watermarked.jpg', '© Jane Doe');

Command Line: ImageMagick

# Text watermark bottom-right
convert photo.jpg -font Arial -pointsize 40 \
  -fill "rgba(255,255,255,0.5)" -gravity southeast \
  -annotate +20+20 "© Jane Doe" watermarked.jpg

# Logo watermark bottom-right
composite -gravity southeast -geometry +20+20 \
  -dissolve 50% logo.png photo.jpg watermarked.jpg

# Tiled watermark
convert photo.jpg logo.png -tile -dissolve 30% \
  -gravity center -composite watermarked.jpg

Batch Watermarking

Python: Watermark an Entire Directory

from pathlib import Path
from PIL import Image, ImageDraw, ImageFont

def batch_watermark(source_dir: str, output_dir: str, text: str):
    Path(output_dir).mkdir(exist_ok=True)
    font = ImageFont.truetype('arial.ttf', 30)

    for path in Path(source_dir).glob('*.jpg'):
        with Image.open(path).convert('RGBA') as img:
            watermark = Image.new('RGBA', img.size, (0, 0, 0, 0))
            draw = ImageDraw.Draw(watermark)
            bbox = draw.textbbox((0, 0), text, font=font)
            tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
            x, y = img.width - tw - 20, img.height - th - 20
            draw.text((x, y), text, font=font, fill=(255, 255, 255, 120))
            watermarked = Image.alpha_composite(img, watermark)
            watermarked.convert('RGB').save(Path(output_dir) / path.name, quality=95)

batch_watermark('photos/', 'watermarked/', '© Jane Doe 2025')

ImageMagick: Batch All JPGs

mkdir watermarked
for img in *.jpg; do
  convert "$img" -font Arial -pointsize 40 \
    -fill "rgba(255,255,255,0.5)" -gravity southeast \
    -annotate +20+20 "© Jane Doe" "watermarked/$img"
done

Removing Watermarks

If you need to remove a watermark (from your own images or with permission), approaches include:

• Crop — If the watermark is near the edge, crop it out
• Clone stamp — Photoshop/GIMP manual removal
• Content-aware fill — Modern editors can reconstruct areas behind watermarks
• Blur — A strong blur over the watermark area as a last resort

Note: Removing watermarks from someone else's copyrighted work without permission is illegal in most jurisdictions.

Legal Considerations

• Watermarking establishes a visible copyright claim but doesn't replace formal registration
• In many countries, removing a watermark is a violation of the Digital Millennium Copyright Act (DMCA)
• A watermark alone may not prevent theft but strengthens your legal position
• For maximum protection, combine watermarks with metadata (EXIF copyright fields) and low-resolution previews

Conclusion

Watermarking is a simple but effective way to protect your visual content and promote your brand. The Image Watermark tool makes it easy to add text or logo watermarks in your browser with full privacy. For batch processing, use the programmatic approaches above to automate watermarking across entire image libraries.