# Watermark Image API (`parseforge/watermark-image-api`) Actor

Add text or logo watermarks to images in bulk. Control opacity, size, position, font, and output format. Supports JPEG, PNG, and WebP.

- **URL**: https://apify.com/parseforge/watermark-image-api.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 10 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### Watermark Image API

**Add text or logo watermarks to images in bulk, with full control over opacity, size, position, and font.** Upload JPEG, PNG, or WebP files and get watermarked versions back in your chosen format. No design tools or manual editing needed.

Manually watermarking images one by one is slow and inconsistent. This API applies text or logo watermarks to any number of images at once, with precise control over placement, transparency, and size. It works with JPEG, PNG, and WebP files and returns the processed images in the format you need.

| Who uses it | What they scrape Watermark Image API for |
|---|---|
| E-commerce sellers | Protect product photos before publishing them to marketplaces |
| Photographers | Add a consistent copyright mark to client proofs and portfolios |
| Social media managers | Brand images for multiple platforms in one batch |
| Content creators | Stamp a logo on thumbnails and promotional graphics |

### What it does

This Actor takes uploaded images and applies a text or logo watermark, returning each watermarked image as a downloadable file.

- 🔤 **Text watermark:** custom text with font family, color, opacity, size, letter spacing, and background box.
- 🖼️ **Logo watermark:** upload a PNG, JPEG, or WebP logo and control its opacity and scale.
- 📍 **Flexible positioning:** corners, center, diagonal, or custom offsets by percentage.
- 📦 **Batch processing:** upload multiple images and watermark them all in one run.
- 🔄 **Format conversion:** output as JPEG, PNG, or WebP regardless of input format.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Watermark Image API data

**🛍️ Protect product images for e-commerce.**

An online store owner uploads a folder of product photos, adds their brand name as a semi-transparent text watermark in the corner, and exports JPEGs ready for the storefront.

**📸 Batch watermark client photo proofs.**

A photographer uploads a set of proofs, places a diagonal logo watermark across each image, and sends the watermarked PNGs to the client for review.

**📱 Brand social media graphics.**

A social media manager uploads promotional images, adds the company logo at a small size in the bottom right, and exports WebP files optimized for web use.

**🎬 Stamp thumbnails for video content.**

A YouTuber uploads thumbnail images, applies a bold text watermark with a background box, and downloads the watermarked JPEGs for upload to the platform.

### Why choose this scraper

|  | What you get |
|---|---|
| **Batch watermarking** | Process many images in a single run with identical settings |
| **Text and logo support** | Use either a text string or an uploaded logo image as the watermark |
| **Fine-grained control** | Adjust opacity, size, position, font, color, and spacing |
| **Multiple output formats** | Export watermarked images as JPEG, PNG, or WebP |

### How it compares

This Actor adds watermarks to your own images. The competitor below is a TikTok scraper that provides no-watermark download links for TikTok videos.

| Feature | ParseForge | Advanced Search TikTok API (free-watermark videos) |
|---|---|---|
| Add text watermark to images | Yes | Not listed |
| Add logo watermark to images | Yes | Not listed |
| Batch process multiple images | Yes | Not listed |
| Control watermark opacity and size | Yes | Not listed |
| Export as JPEG, PNG, or WebP | Yes | Not listed |
| Provide no-watermark video download links | Not listed | Yes |

### Configure the run

Upload the images you want to watermark, then choose a text or logo watermark and adjust its appearance and position. The Actor processes every image with the same settings and returns the watermarked files. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "imageFiles": [
    "https://github.com/ParseForge/apify-assets/blob/65f2790e17ebc08b3c4ae5ca92cbb43a444c2ab1/watermark-image-api/original.avif?raw=true"
  ],
  "fontFamily": "inter",
  "textColor": "#ffffff",
  "textOpacity": 90,
  "textScale": 50,
  "letterSpacing": 0,
  "backgroundOpacity": 35,
  "logoFile": "https://raw.githubusercontent.com/ParseForge/apify-assets/3fb8b140a224231d5c4ffdf30fc22f78c581cf3f/watermark-image-api/react_logo.png",
  "logoOpacity": 30,
  "logoScale": 80,
  "position": "center",
  "offsetXPercent": 0,
  "offsetYPercent": 0,
  "outputFormat": "png"
}
```

### Pricing

Pay-per-result: **$0.0025 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.25 |
| 1,000 results | $2.50 |
| 10,000 results | $25.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Watermark Image API](https://apify.com/parseforge/watermark-image-api?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Watermark Image API through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/watermark-image-api"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why is my watermark not appearing on the images?**

Check that you have provided either watermarkText or logoFile. If both are empty, no watermark is applied. Also ensure the opacity is not set to 0.

**Why is the logo watermark not showing even though I uploaded a logo?**

If you also provided watermarkText, the text takes precedence. Remove the text to use the logo. Also check that the logo file is a valid PNG, JPEG, or WebP.

**Why is the text watermark too small or too large?**

Adjust the textScale parameter. It controls the watermark size as a percentage of the image width. Increase it for a larger watermark, decrease for smaller.

**Why is the watermark position not where I expected?**

Make sure you selected the correct position. If using 'custom', set offsetXPercent and offsetYPercent to the desired offsets from the anchor point.

**Why did the output format change from my input?**

The Actor uses the outputFormat you specify, not the input format. If you want to keep the original format, set outputFormat to match your input files.

### FAQ

| Question | Answer |
|---|---|
| What image formats can I upload? | The Actor accepts JPEG, PNG, and WebP images. You can upload multiple files at once. |
| Can I use both text and logo watermarks at the same time? | No, you choose either a text watermark or a logo watermark. If both are provided, the logo takes precedence. |
| How do I control the transparency of the watermark? | Use the opacity settings. For text, set textOpacity from 0 to 100. For logos, set logoOpacity from 0 to 100. Higher values make the watermark more visible. |
| Can I place the watermark anywhere on the image? | Yes. Choose from corners, center, diagonal, or custom. For custom, set offsetXPercent and offsetYPercent to position it precisely. |
| What output formats are supported? | You can export watermarked images as JPEG, PNG, or WebP. JPEG gives smaller files, PNG supports transparency, and WebP is optimized for the web. |
| Is there a limit on the number of images I can process? | There is no fixed limit in the Actor itself. You can upload as many images as your plan allows. |
| Can I change the font of the text watermark? | Yes, choose from Inter, Arial, Impact, Verdana, Courier, Comic Sans, or Times New Roman. |
| How do I make the watermark text larger or smaller? | Adjust the textScale parameter. It sets the watermark size as a percentage of the image width, from 5% to 100%. |
| Can I add a background behind the text watermark? | Yes, set backgroundOpacity to a value greater than 0. A value of 0 means no background, and 100 means a solid background. |
| Does the Actor modify my original images? | No, the original images are not changed. The Actor creates new watermarked versions and returns them as output files. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by ParseForge. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `imageFiles` (type: `array`):

Upload images to watermark. Supports JPEG, PNG, and WebP formats. You can process multiple images at once.

## `watermarkText` (type: `string`):

Text to display as watermark. Only used if logo is not provided. Use either text OR logo watermark, not both.

## `fontFamily` (type: `string`):

Font family for text watermark. Choose from: Inter (modern), Arial (classic), Impact (bold), Verdana (readable), Courier (monospace), Comic Sans (casual), Times New Roman (traditional).

## `textColor` (type: `string`):

Color for text watermark in HEX format (e.g., #FFFFFF for white, #000000 for black).

## `textOpacity` (type: `integer`):

Transparency of text watermark (0-100%). Higher values = more visible watermark.

## `textScale` (type: `integer`):

Size of text watermark as percentage of image width (5-100%). Higher values = larger watermark.

## `letterSpacing` (type: `integer`):

Spacing between letters as percentage of font size (0-200%). Higher values = more space between letters.

## `backgroundOpacity` (type: `integer`):

Transparency of text background box (0-100%). 0 = no background, 100 = solid background. Only applies to text watermarks.

## `logoFile` (type: `string`):

Upload a single logo image to use as watermark. Only used if watermark text is not provided. Use either text OR logo watermark, not both. Supports PNG, JPEG, and WebP formats.

## `logoOpacity` (type: `integer`):

Transparency of logo watermark (0-100%). Higher values = more visible logo.

## `logoScale` (type: `integer`):

Size of logo watermark as percentage of image width (5-100%). Higher values = larger logo.

## `position` (type: `string`):

Where to place the watermark on the image. Corner positions, center, diagonal (across image), or custom offsets.

## `offsetXPercent` (type: `integer`):

Horizontal offset from position anchor as percentage (0-100). Only used when position is set to 'custom'.

## `offsetYPercent` (type: `integer`):

Vertical offset from position anchor as percentage (0-100). Only used when position is set to 'custom'.

## `outputFormat` (type: `string`):

Format for watermarked images. JPEG for smaller files, PNG for transparency support, WebP for modern web optimization.

## Actor input object example

```json
{
  "imageFiles": [
    "https://github.com/ParseForge/apify-assets/blob/65f2790e17ebc08b3c4ae5ca92cbb43a444c2ab1/watermark-image-api/original.avif?raw=true"
  ],
  "watermarkText": "",
  "fontFamily": "inter",
  "textColor": "#ffffff",
  "textOpacity": 90,
  "textScale": 50,
  "letterSpacing": 0,
  "backgroundOpacity": 35,
  "logoFile": "https://raw.githubusercontent.com/ParseForge/apify-assets/3fb8b140a224231d5c4ffdf30fc22f78c581cf3f/watermark-image-api/react_logo.png",
  "logoOpacity": 30,
  "logoScale": 80,
  "position": "center",
  "offsetXPercent": 0,
  "offsetYPercent": 0,
  "outputFormat": "png"
}
```

# Actor output Schema

## `results` (type: `string`):

Complete dataset with all watermarked images including download URLs, original image references, timestamps, and processing status

## `overview` (type: `string`):

Overview view of watermarked images with key fields displayed in a table format

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "imageFiles": [
        "https://github.com/ParseForge/apify-assets/blob/65f2790e17ebc08b3c4ae5ca92cbb43a444c2ab1/watermark-image-api/original.avif?raw=true"
    ],
    "watermarkText": "",
    "fontFamily": "inter",
    "textColor": "#ffffff",
    "textOpacity": 90,
    "textScale": 50,
    "letterSpacing": 0,
    "backgroundOpacity": 35,
    "logoFile": "https://raw.githubusercontent.com/ParseForge/apify-assets/3fb8b140a224231d5c4ffdf30fc22f78c581cf3f/watermark-image-api/react_logo.png",
    "logoOpacity": 30,
    "logoScale": 80,
    "position": "center",
    "offsetXPercent": 0,
    "offsetYPercent": 0,
    "outputFormat": "png"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/watermark-image-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "imageFiles": ["https://github.com/ParseForge/apify-assets/blob/65f2790e17ebc08b3c4ae5ca92cbb43a444c2ab1/watermark-image-api/original.avif?raw=true"],
    "watermarkText": "",
    "fontFamily": "inter",
    "textColor": "#ffffff",
    "textOpacity": 90,
    "textScale": 50,
    "letterSpacing": 0,
    "backgroundOpacity": 35,
    "logoFile": "https://raw.githubusercontent.com/ParseForge/apify-assets/3fb8b140a224231d5c4ffdf30fc22f78c581cf3f/watermark-image-api/react_logo.png",
    "logoOpacity": 30,
    "logoScale": 80,
    "position": "center",
    "offsetXPercent": 0,
    "offsetYPercent": 0,
    "outputFormat": "png",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/watermark-image-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "imageFiles": [
    "https://github.com/ParseForge/apify-assets/blob/65f2790e17ebc08b3c4ae5ca92cbb43a444c2ab1/watermark-image-api/original.avif?raw=true"
  ],
  "watermarkText": "",
  "fontFamily": "inter",
  "textColor": "#ffffff",
  "textOpacity": 90,
  "textScale": 50,
  "letterSpacing": 0,
  "backgroundOpacity": 35,
  "logoFile": "https://raw.githubusercontent.com/ParseForge/apify-assets/3fb8b140a224231d5c4ffdf30fc22f78c581cf3f/watermark-image-api/react_logo.png",
  "logoOpacity": 30,
  "logoScale": 80,
  "position": "center",
  "offsetXPercent": 0,
  "offsetYPercent": 0,
  "outputFormat": "png"
}' |
apify call parseforge/watermark-image-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/watermark-image-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ay0BA6GbexFyaCNHh/builds/hyrclRgVbDr2lvHlZ/openapi.json
