# PDF Watermark Generator API 🎨 **Professional PDF Watermarking & Branding Solution** Add professional watermarks to your PDF documents with pixel-perfect precision and enterprise-grade processing. Our API offers comprehensive watermarking solutions for branding, copyright protection, and document identification with real-time batch processing. --- ## 🚀 Quick Start ### Base URL ``` https://... ``` ### Authentication Include your RapidAPI key in the request headers: ``` X-RapidAPI-Key: your-rapidapi-key-here X-RapidAPI-Host: your-rapidapi-host ``` ### Simple Example ```bash curl -X POST "https://.../api/watermark/text" \ -H "X-RapidAPI-Key: YOUR_KEY" \ -F "file=@document.pdf" \ -F "text=CONFIDENTIAL" \ -F "opacity=0.3" \ -F "position=center" ``` --- ## 🎨 Core Features ### ✨ Text Watermarks - **Custom Text**: Any text up to 100 characters with Unicode support - **Full Styling Control**: Font size, color, opacity, rotation - **Perfect Positioning**: 5 strategic position options - **Professional Quality**: Vector-quality output ### 🖼️ Image Watermarks - **Logo Support**: PNG/JPG images with transparency preservation - **Flexible Scaling**: 0.1x to 2.0x size adjustment - **High Quality**: Professional rendering with aspect ratio preservation - **Transparency**: Full PNG alpha channel support ### 🚀 Batch Processing - **Volume Processing**: Up to 50 PDFs simultaneously - **Real-time Tracking**: Live progress via WebSocket connections - **Webhook Integration**: Automated completion notifications - **Consistent Results**: Same watermark applied to all files ### 🛡️ Security & Privacy - **Zero Storage**: Documents automatically deleted within 24 hours - **Secure Processing**: Files processed in isolated environments - **No Data Retention**: We never store your documents or watermarks - **HTTPS Only**: All communications encrypted in transit --- ## 📋 API Endpoints ### 1. Text Watermark **POST** `/api/watermark/text` Add custom text watermarks with full styling control. **Request Parameters:** - `file` (required): PDF document to watermark (max 100MB) - `text` (required): Watermark text content (1-100 characters) - `position` (optional): Watermark position - center, top-left, top-right, bottom-left, bottom-right (default: center) - `opacity` (optional): Transparency level 0.0-1.0 (default: 0.3) - `font_size` (optional): Font size in points 8-72 (default: 24) - `color` (optional): Hex color code (default: #000000) - `rotation` (optional): Rotation angle -180° to +180° (default: 0) **Example Request:** ```bash curl -X POST "https://.../api/watermark/text" \ -H "X-RapidAPI-Key: YOUR_KEY" \ -F "file=@business-report.pdf" \ -F "text=CONFIDENTIAL" \ -F "position=center" \ -F "opacity=0.3" \ -F "font_size=36" \ -F "color=#FF0000" \ -F "rotation=45" ``` **Response:** ```json { "success": true, "url": "https://secure-cdn.com/watermarked/abc123.pdf", "watermark_type": "text", "pages_watermarked": 5, "watermark_text": "CONFIDENTIAL", "processing_time": "2100ms" } ``` ### 2. Image Watermark **POST** `/api/watermark/image` Add professional image/logo watermarks with transparency support. **Request Parameters:** - `file` (required): PDF document to watermark - `watermark` (required): Watermark image file PNG/JPG (max 10MB) - `position` (optional): Watermark position (default: center) - `opacity` (optional): Transparency level 0.0-1.0 (default: 0.5) - `scale` (optional): Size scaling factor 0.1-2.0 (default: 1.0) **Example Request:** ```bash curl -X POST "https://.../api/watermark/image" \ -H "X-RapidAPI-Key: YOUR_KEY" \ -F "file=@presentation.pdf" \ -F "watermark=@company-logo.png" \ -F "position=bottom-right" \ -F "opacity=0.7" \ -F "scale=0.5" ``` **Response:** ```json { "success": true, "url": "https://secure-cdn.com/watermarked/def456.pdf", "watermark_type": "image", "pages_watermarked": 12, "watermark_format": "png", "watermark_size": 45678, "processing_time": "3200ms" } ``` ### 3. Batch Text Watermarking **POST** `/api/watermark/text/batch` Apply the same text watermark to multiple PDF documents. **Request Parameters:** - `files` (required): Array of PDF files (max 50 files, 500MB total) - `text` (required): Watermark text for all files - `position` (optional): Position for all files (default: center) - `opacity` (optional): Opacity for all files (default: 0.3) - `font_size` (optional): Font size for all files (default: 24) - `color` (optional): Text color for all files (default: #000000) - `rotation` (optional): Rotation angle for all files (default: 0) - `webhook_url` (optional): URL to receive completion notification **Example Request:** ```bash curl -X POST "https://.../api/watermark/text/batch" \ -H "X-RapidAPI-Key: YOUR_KEY" \ -F "files=@document1.pdf" \ -F "files=@document2.pdf" \ -F "files=@document3.pdf" \ -F "text=DRAFT" \ -F "position=top-right" \ -F "opacity=0.4" \ -F "color=#FF0000" \ -F "webhook_url=https://yourapp.com/webhook" ``` **Response:** ```json { "job_id": "550e8400-e29b-41d4-a716-446655440000", "status": "pending", "message": "Batch text watermark job created", "total_items": 3, "created_at": "2024-01-15T10:30:00Z" } ``` ### 4. Batch Image Watermarking **POST** `/api/watermark/image/batch` Apply the same image watermark to multiple PDF documents. **Request Parameters:** - `watermark` (required): Watermark image for all files - `files` (required): Array of PDF files to watermark - `position` (optional): Position for all files - `opacity` (optional): Opacity for all files - `scale` (optional): Scale for all files - `webhook_url` (optional): Completion notification URL **Example Request:** ```bash curl -X POST "https://.../api/watermark/image/batch" \ -H "X-RapidAPI-Key: YOUR_KEY" \ -F "watermark=@company-logo.png" \ -F "files=@report1.pdf" \ -F "files=@report2.pdf" \ -F "position=bottom-left" \ -F "opacity=0.6" \ -F "scale=0.3" ``` ### 5. Job Management **GET** `/api/jobs/{job_id}/status` Track batch job progress and status. **Example Request:** ```bash curl -X GET "https://.../api/jobs/550e8400-e29b-41d4-a716-446655440000/status" \ -H "X-RapidAPI-Key: YOUR_KEY" ``` **Response:** ```json { "job_id": "550e8400-e29b-41d4-a716-446655440000", "status": "processing", "progress": 67, "message": "Watermarking file 2 of 3: document2.pdf", "total_items": 3, "completed_items": 2, "failed_items": 0, "current_file": "document2.pdf", "estimated_completion": "2024-01-15T10:35:00Z" } ``` **GET** `/api/jobs/{job_id}/results` Retrieve completed batch job results and download links. **Response:** ```json { "job_id": "550e8400-e29b-41d4-a716-446655440000", "status": "completed", "total_files": 3, "successful_files": 3, "failed_files": 0, "download_all_zip": "https://secure-cdn.com/batch-results/batch123.zip", "zip_status": "ready", "zip_expires_in": "30 minutes", "individual_files": [ { "filename": "document1.pdf", "watermarked_filename": "document1_watermarked.pdf", "download_url": "https://secure-cdn.com/watermarked/file1.pdf", "status": "success", "pages_watermarked": 5, "processing_time": "2100ms" } ], "watermark_summary": { "watermark_type": "text", "settings_used": { "text": "DRAFT", "position": "top-right", "opacity": 0.4, "color": "#FF0000" }, "total_pages_processed": 15, "average_processing_time": "1800ms" } } ``` **POST** `/api/jobs/{job_id}/cancel` Cancel a running batch watermarking job. **Response:** ```json { "success": true, "message": "Job cancelled successfully", "files_processed": 1, "partial_results_available": true } ``` --- ## 🔄 Real-time Updates ### WebSocket Connection Connect to receive live progress updates for batch jobs: ```javascript const socket = new WebSocket('wss://.../api/websocket/jobs/YOUR_JOB_ID', { headers: { 'X-RapidAPI-Key': 'YOUR_KEY' } }); socket.onmessage = function(event) { const update = JSON.parse(event.data); console.log('Watermark job update:', update); switch(update.type) { case 'job_started': console.log('Watermarking job started'); break; case 'progress': console.log(`Progress: ${update.data.progress}%`); updateProgressBar(update.data.progress); break; case 'file_completed': console.log(`File completed: ${update.data.filename}`); console.log(`Pages watermarked: ${update.data.pages_watermarked}`); break; case 'file_failed': console.log(`File failed: ${update.data.filename} - ${update.data.error}`); break; case 'job_completed': console.log('All files watermarked successfully!'); downloadResults(update.data.download_url); break; } }; socket.onerror = function(error) { console.error('WebSocket error:', error); }; ``` ### Webhook Integration Configure webhooks for automated notifications: ```bash curl -X POST "https://.../api/webhooks" \ -H "X-RapidAPI-Key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{ "url": "https://yourapp.com/webhooks/watermark", "events": ["job.completed", "job.failed", "job.progress"], "secret": "your-webhook-secret" }' ``` **Webhook Payload Example:** ```json { "event": "job.completed", "job_id": "550e8400-e29b-41d4-a716-446655440000", "timestamp": "2024-01-15T10:35:00Z", "data": { "status": "completed", "total_files": 3, "successful_files": 3, "failed_files": 0, "download_url": "https://secure-cdn.com/batch-results/batch123.zip", "watermark_summary": { "type": "text", "text": "CONFIDENTIAL", "total_pages_processed": 15 } } } ``` --- ## 💡 Use Cases & Applications ### 🏢 Corporate Branding **Company Document Branding** ```javascript // Add company logo to all business documents const brandDocuments = async (documents, companyLogo) => { const formData = new FormData(); documents.forEach(doc => formData.append('files', doc)); formData.append('watermark', companyLogo); formData.append('position', 'bottom-right'); formData.append('opacity', '0.7'); formData.append('scale', '0.3'); formData.append('webhook_url', 'https://company.com/branding-complete'); const response = await fetch('https://.../api/watermark/image/batch', { method: 'POST', headers: { 'X-RapidAPI-Key': 'YOUR_KEY' }, body: formData }); return response.json(); }; ``` **Legal Document Marking** ```python import requests def mark_legal_documents(files, status="CONFIDENTIAL"): url = "https://.../api/watermark/text/batch" headers = {"X-RapidAPI-Key": "YOUR_KEY"} # Prepare files for upload files_data = [('files', open(f, 'rb')) for f in files] data = { "text": status, "position": "center", "opacity": 0.2, "font_size": 48, "color": "#FF0000", "rotation": 45, "webhook_url": "https://law-firm.com/webhook/documents" } try: response = requests.post(url, headers=headers, files=files_data, data=data) return response.json() finally: # Close file handles for _, file_handle in files_data: file_handle.close() # Usage job = mark_legal_documents(["contract1.pdf", "agreement2.pdf"], "CONFIDENTIAL") print(f"Legal marking job started: {job['job_id']}") ``` ### 🎨 Creative & Marketing **Marketing Material Watermarking** ```javascript // Add "PROOF" watermarks to marketing designs const createProofCopies = async (designFiles) => { const watermarkSettings = { text: "PROOF - NOT FOR PRINT", position: "center", opacity: 0.4, font_size: 32, color: "#FF6B35", rotation: -15 }; const formData = new FormData(); designFiles.forEach(file => formData.append('files', file)); Object.entries(watermarkSettings).forEach(([key, value]) => { formData.append(key, value.toString()); }); const response = await fetch('https://.../api/watermark/text/batch', { method: 'POST', headers: { 'X-RapidAPI-Key': process.env.RAPIDAPI_KEY }, body: formData }); return response.json(); }; ``` ### 📚 Educational Applications **Student Assignment Protection** ```python def watermark_student_assignments(assignment_files, student_name, course_code): """Add student identification watermarks""" watermark_text = f"{student_name} - {course_code}" url = "https://.../api/watermark/text/batch" headers = {"X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"]} files_data = [('files', open(f, 'rb')) for f in assignment_files] data = { "text": watermark_text, "position": "bottom-left", "opacity": 0.3, "font_size": 12, "color": "#666666" } try: response = requests.post(url, headers=headers, files=files_data, data=data) job = response.json() # Track job completion return monitor_watermark_job(job['job_id']) finally: for _, file_handle in files_data: file_handle.close() def monitor_watermark_job(job_id): """Monitor job progress and return results""" headers = {"X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"]} status_url = f"https://.../api/jobs/{job_id}/status" while True: response = requests.get(status_url, headers=headers) status = response.json() print(f"Job {job_id}: {status['progress']}% - {status['message']}") if status['status'] in ['completed', 'failed']: break time.sleep(5) # Wait 5 seconds before checking again # Get final results results_url = f"https://.../api/jobs/{job_id}/results" results = requests.get(results_url, headers=headers).json() return results ``` ### 🏗️ Web Application Integration **React.js Watermarking Component** ```jsx import React, { useState, useEffect, useCallback } from 'react'; const WatermarkGenerator = () => { const [files, setFiles] = useState([]); const [watermarkType, setWatermarkType] = useState('text'); const [watermarkSettings, setWatermarkSettings] = useState({ text: 'CONFIDENTIAL', position: 'center', opacity: 0.3, font_size: 24, color: '#000000', rotation: 0 }); const [job, setJob] = useState(null); const [progress, setProgress] = useState(0); const [results, setResults] = useState(null); // WebSocket connection for real-time updates const connectWebSocket = useCallback((jobId) => { const ws = new WebSocket(`wss://.../api/websocket/jobs/${jobId}`, { headers: { 'X-RapidAPI-Key': process.env.REACT_APP_RAPIDAPI_KEY } }); ws.onmessage = (event) => { const update = JSON.parse(event.data); switch(update.type) { case 'progress': setProgress(update.data.progress); break; case 'job_completed': setProgress(100); fetchResults(jobId); ws.close(); break; case 'job_failed': setJob(prev => ({ ...prev, status: 'failed', error: update.data.error })); ws.close(); break; } }; return ws; }, []); const addWatermarks = async () => { const formData = new FormData(); files.forEach(file => formData.append('files', file)); // Add watermark settings Object.entries(watermarkSettings).forEach(([key, value]) => { if (key === 'text' || value !== null) { formData.append(key, value.toString()); } }); try { const endpoint = watermarkType === 'text' ? '/api/watermark/text/batch' : '/api/watermark/image/batch'; const response = await fetch(`https://...${endpoint}`, { method: 'POST', headers: { 'X-RapidAPI-Key': process.env.REACT_APP_RAPIDAPI_KEY }, body: formData }); const jobData = await response.json(); setJob(jobData); connectWebSocket(jobData.job_id); } catch (error) { console.error('Watermarking failed:', error); } }; const fetchResults = async (jobId) => { const response = await fetch(`https://.../api/jobs/${jobId}/results`, { headers: { 'X-RapidAPI-Key': process.env.REACT_APP_RAPIDAPI_KEY } }); const resultsData = await response.json(); setResults(resultsData); }; return (

PDF Watermark Generator 🎨

{/* File Upload */}

<input type="file" multiple accept=".pdf" onChange={(e) => setFiles(Array.from(e.target.files))} />

Selected: {files.length} files

{/* Watermark Type Selection */}

<label> <input type="radio" value="text" checked={watermarkType === 'text'} onChange={(e) => setWatermarkType(e.target.value)} /> Text Watermark </label> <label> <input type="radio" value="image" checked={watermarkType === 'image'} onChange={(e) => setWatermarkType(e.target.value)} /> Image Watermark </label>

{/* Text Watermark Settings */} {watermarkType === 'text' && (

<input type="text" placeholder="Watermark text" value={watermarkSettings.text} onChange={(e) => setWatermarkSettings(prev => ({...prev, text: e.target.value}))} /> <select value={watermarkSettings.position} onChange={(e) => setWatermarkSettings(prev => ({...prev, position: e.target.value}))} > <option value="center">Center</option> <option value="top-left">Top Left</option> <option value="top-right">Top Right</option> <option value="bottom-left">Bottom Left</option> <option value="bottom-right">Bottom Right</option> </select> <input type="range" min="0" max="1" step="0.1" value={watermarkSettings.opacity} onChange={(e) => setWatermarkSettings(prev => ({...prev, opacity: parseFloat(e.target.value)}))} /> Opacity: {watermarkSettings.opacity} <input type="number" min="8" max="72" value={watermarkSettings.font_size} onChange={(e) => setWatermarkSettings(prev => ({...prev, font_size: parseInt(e.target.value)}))} /> Font Size <input type="color" value={watermarkSettings.color} onChange={(e) => setWatermarkSettings(prev => ({...prev, color: e.target.value}))} /> <input type="range" min="-180" max="180" value={watermarkSettings.rotation} onChange={(e) => setWatermarkSettings(prev => ({...prev, rotation: parseInt(e.target.value)}))} /> Rotation: {watermarkSettings.rotation}°

)} {/* Action Button */} <button onClick={addWatermarks} disabled={files.length === 0 || (job && job.status === 'processing')} className="watermark-btn" > {job && job.status === 'processing' ? 'Processing...' : 'Add Watermarks 🎨'} </button> {/* Progress Display */} {job && job.status === 'processing' && (

Progress: {progress}% - {job.message}

)} {/* Results Display */} {results && (

Watermarked Files Ready! 🎉

📦 Download All Files (ZIP)

Individual Files:

{results.individual_files.map((file, index) => (

📄 {file.watermarked_filename} {file.pages_watermarked} pages • {file.processing_time}

))}

Summary:

✅ Total Files: {results.total_files}

✅ Successful: {results.successful_files}

❌ Failed: {results.failed_files}

📄 Total Pages Processed: {results.watermark_summary.total_pages_processed}

)}

); }; export default WatermarkGenerator; ``` **Node.js Backend Integration** ```javascript const express = require('express'); const multer = require('multer'); const axios = require('axios'); const WebSocket = require('ws'); const app = express(); const upload = multer({ storage: multer.memoryStorage() }); // Watermark endpoint app.post('/watermark', upload.array('files'), async (req, res) => { try { const { watermark_type, text, position, opacity, font_size, color, rotation } = req.body; const files = req.files; if (!files || files.length === 0) { return res.status(400).json({ error: 'No files provided' }); } const formData = new FormData(); // Add files files.forEach(file => { formData.append('files', file.buffer, file.originalname); }); // Add watermark settings if (watermark_type === 'text') { formData.append('text', text); formData.append('position', position || 'center'); formData.append('opacity', opacity || '0.3'); formData.append('font_size', font_size || '24'); formData.append('color', color || '#000000'); formData.append('rotation', rotation || '0'); } // Add webhook for completion notification formData.append('webhook_url', `${process.env.BASE_URL}/webhook/watermark-complete`); const endpoint = watermark_type === 'text' ? 'https://.../api/watermark/text/batch' : 'https://.../api/watermark/image/batch'; const response = await axios.post(endpoint, formData, { headers: { 'X-RapidAPI-Key': process.env.RAPIDAPI_KEY, ...formData.getHeaders() } }); const job = response.data; // Store job in database for user tracking await saveJobToDatabase(job.job_id, req.user.id, 'watermark'); res.json({ success: true, jobId: job.job_id, message: 'Watermarking job started', totalFiles: files.length }); } catch (error) { console.error('Watermarking error:', error); res.status(500).json({ error: 'Watermarking failed', details: error.response?.data || error.message }); } }); // WebSocket connection for real-time updates app.ws('/watermark-progress/:jobId', (ws, req) => { const { jobId } = req.params; // Connect to API WebSocket const apiWs = new WebSocket(`wss://.../api/websocket/jobs/${jobId}`, { headers: { 'X-RapidAPI-Key': process.env.RAPIDAPI_KEY } }); // Forward messages to client apiWs.on('message', (data) => { ws.send(data); }); // Handle client disconnect ws.on('close', () => { apiWs.close(); }); apiWs.on('error', (error) => { ws.send(JSON.stringify({ type: 'error', message: error.message })); }); }); // Webhook endpoint for completion notifications app.post('/webhook/watermark-complete', (req, res) => { const { event, job_id, data } = req.body; if (event === 'job.completed') { // Notify user via email, push notification, etc. notifyUser(job_id, { type: 'watermark_completed', message: 'Your documents have been watermarked!', downloadUrl: data.download_url, summary: { totalFiles: data.total_files, successfulFiles: data.successful_files, failedFiles: data.failed_files } }); // Update job status in database updateJobStatus(job_id, 'completed', data); } res.status(200).send('OK'); }); // Helper functions async function saveJobToDatabase(jobId, userId, jobType) { // Implementation depends on your database // Store job details for user tracking } async function updateJobStatus(jobId, status, data) { // Update job status and results in database } async function notifyUser(jobId, notification) { // Send notification to user (email, push, websocket, etc.) } ``` --- ## 🔧 Advanced Features ### Watermark Templates **GET** `/api/templates/watermark` Get pre-designed watermark templates for common use cases. ```bash curl -X GET "https://.../api/templates/watermark?category=legal" \ -H "X-RapidAPI-Key: YOUR_KEY" ``` **Response:** ```json { "templates": [ { "template_id": "legal-confidential", "name": "Confidential Red Diagonal", "category": "legal", "type": "text", "preview_url": "https://cdn.example.com/templates/legal-confidential.png", "settings": { "text": "CONFIDENTIAL", "position": "center", "opacity": 0.3, "font_size": 48, "color": "#FF0000", "rotation": 45 } } ] } ``` **POST** `/api/templates/watermark` Apply a pre-designed template to your PDF: ```bash curl -X POST "https://.../api/templates/watermark" \ -H "X-RapidAPI-Key: YOUR_KEY" \ -F "file=@document.pdf" \ -F "template_id=legal-confidential" \ -F "custom_text=TOP SECRET" ``` --- ## 📊 Error Handling ### Common Error Responses **Invalid File Format** ```json { "error": "INVALID_FILE_FORMAT", "message": "Only PDF files are supported for watermarking", "details": { "file_type_detected": "image/jpeg", "supported_types": ["application/pdf"] } } ``` **Watermark Image Too Large** ```json { "error": "WATERMARK_TOO_LARGE", "message": "Watermark image exceeds 10MB limit", "details": { "image_size": 15728640, "max_size": 10485760 } } ``` **Invalid Text Parameters** ```json { "error": "VALIDATION_ERROR", "message": "Text watermark cannot exceed 100 characters", "details": { "text_length": 150, "max_length": 100 } } ``` ### Retry Logic Example ```python import requests import time from typing import Optional class WatermarkAPI: def __init__(self, api_key: str): self.api_key = api_key self.base_url = "https://..." self.headers = {"X-RapidAPI-Key": api_key} def add_text_watermark_with_retry(self, file_path: str, text: str, max_retries: int = 3) -> Optional[dict]: """Add text watermark with automatic retry logic""" for attempt in range(max_retries): try: with open(file_path, 'rb') as file: files = {'file': file} data = { 'text': text, 'position': 'center', 'opacity': 0.3 } response = requests.post( f"{self.base_url}/api/watermark/text", headers=self.headers, files=files, data=data, timeout=30 ) if response.status_code == 200: return response.json() elif response.status_code == 429: # Rate limit wait_time = 2 ** attempt # Exponential backoff print(f"Rate limited. Waiting {wait_time}s before retry...") time.sleep(wait_time) else: print(f"Attempt {attempt + 1} failed: {response.status_code}") if attempt == max_retries - 1: response.raise_for_status() except requests.exceptions.Timeout: print(f"Attempt {attempt + 1} timed out") if attempt == max_retries - 1: raise except requests.exceptions.RequestException as e: print(f"Attempt {attempt + 1} failed with error: {e}") if attempt == max_retries - 1: raise return None def monitor_batch_job(self, job_id: str, check_interval: int = 5) -> dict: """Monitor batch job until completion""" while True: try: response = requests.get( f"{self.base_url}/api/jobs/{job_id}/status", headers=self.headers ) status = response.json() print(f"Job {job_id}: {status['progress']}% - {status['message']}") if status['status'] in ['completed', 'failed', 'partial']: # Get final results results_response = requests.get( f"{self.base_url}/api/jobs/{job_id}/results", headers=self.headers ) return results_response.json() time.sleep(check_interval) except requests.exceptions.RequestException as e: print(f"Error checking job status: {e}") time.sleep(check_interval) # Usage example api = WatermarkAPI("YOUR_RAPIDAPI_KEY") # Single file with retry result = api.add_text_watermark_with_retry("document.pdf", "CONFIDENTIAL") if result: print(f"Watermarked file: {result['url']}") # Batch job monitoring job_result = api.monitor_batch_job("your-job-id") print(f"Batch completed: {job_result['successful_files']} successful") ``` --- ## 📊 Rate Limits & Pricing ### Rate Limits - **Free Plan**: 100 watermarks/month, 5 files/batch - **Pro Plan**: 50,000 watermarks/month, 25 files/batch - **Enterprise**: Unlimited watermarks, 50 files/batch, priority processing ### File Limits - **PDF Size**: 100MB maximum per file - **Image Watermark**: 10MB maximum (PNG/JPG) - **Batch Total**: 500MB maximum per batch - **Text Length**: 100 characters maximum ### Processing Times - **Single File**: 1-3 seconds per page - **Batch Processing**: 1-2 seconds per page - **Large Files (>50MB)**: 5-10 seconds per page - **Image Watermarks**: 2-5 seconds per page (depending on image complexity) --- ## 🛡️ Security & Privacy ### Data Protection - ✅ **Zero Storage Policy**: All files and watermarks automatically deleted within 24 hours - ✅ **Secure Processing**: Files processed in isolated, encrypted environments - ✅ **No Content Logging**: Document content never logged or monitored - ✅ **HTTPS Only**: All API communications encrypted with TLS 1.3 - ✅ **Watermark Privacy**: Uploaded watermark images are not retained ### Compliance - **GDPR Compliant**: European data protection regulations - **CCPA Compliant**: California privacy rights - **SOC 2 Type II**: Security controls audit - **ISO 27001**: Information security management ### Best Practices 1. **API Key Security**: Store keys securely, never expose in client-side code 2. **Webhook Security**: Use HTTPS endpoints with signature verification 3. **File Validation**: Always validate file types and sizes before upload 4. **Progress Monitoring**: Use WebSockets or polling for job status updates 5. **Error Handling**: Implement proper retry logic with exponential backoff --- ## 🚀 Quick Implementation Guide ### 1. Get Started in 5 Minutes ```bash # Test the API with a simple text watermark curl -X POST "https://.../api/watermark/text" \ -H "X-RapidAPI-Key: YOUR_KEY" \ -F "file=@test-document.pdf" \ -F "text=SAMPLE" \ -F "opacity=0.3" ``` ### 2. Production Integration Checklist - [ ] Obtain RapidAPI key from marketplace - [ ] Test single file watermarking - [ ] Implement error handling and retry logic - [ ] Set up webhook endpoint for batch notifications - [ ] Test batch processing with multiple files - [ ] Implement progress tracking (WebSocket or polling) - [ ] Add file validation (size, format) - [ ] Set up monitoring and logging - [ ] Configure rate limiting handling - [ ] Test different watermark positions and styles ### 3. Sample Integration Code **Python Flask Example:** ```python from flask import Flask, request, jsonify import requests import os app = Flask(__name__) RAPIDAPI_KEY = os.environ["RAPIDAPI_KEY"] @app.route('/watermark', methods=['POST']) def watermark_document(): file = request.files['document'] text = request.form.get('watermark_text', 'CONFIDENTIAL') # Forward to PDF Watermark Generator API files = {'file': (file.filename, file.read(), file.content_type)} data = { 'text': text, 'position': 'center', 'opacity': 0.3, 'color': '#FF0000' } response = requests.post( 'https://.../api/watermark/text', headers={'X-RapidAPI-Key': RAPIDAPI_KEY}, files=files, data=data ) return jsonify(response.json()) if __name__ == '__main__': app.run(debug=True) ``` **Frontend JavaScript Example:** ```javascript async function watermarkPDF(file, settings) { const formData = new FormData(); formData.append('file', file); formData.append('text', settings.text); formData.append('position', settings.position); formData.append('opacity', settings.opacity); try { const response = await fetch('https://.../api/watermark/text', { method: 'POST', headers: { 'X-RapidAPI-Key': 'YOUR_KEY' }, body: formData }); const result = await response.json(); if (result.success) { return { success: true, downloadUrl: result.url, pagesWatermarked: result.pages_watermarked, processingTime: result.processing_time }; } else { throw new Error(result.message || 'Watermarking failed'); } } catch (error) { console.error('Watermarking error:', error); return { success: false, error: error.message }; } } // Usage const fileInput = document.getElementById('pdf-file'); const file = fileInput.files[0]; const settings = { text: 'CONFIDENTIAL', position: 'center', opacity: 0.3 }; watermarkPDF(file, settings).then(result => { if (result.success) { console.log(`Watermarked! Download: ${result.downloadUrl}`); // Show download link to user showDownloadLink(result.downloadUrl); } else { console.error('Failed:', result.error); // Show error message to user showErrorMessage(result.error); } }); ``` --- ## 📞 Support & Resources ### API Support - **Email**: support@bytefuse.in - **Documentation**: https://... - **Status Page**: https://status.bytefuse.in - **Response Time**: < 24 hours ### Developer Resources - **OpenAPI Specification**: Complete API documentation - **Postman Collection**: Ready-to-import API collection - **Code Examples**: GitHub repository with integration samples - **Video Tutorials**: Step-by-step implementation guides ### Community & Help - **Developer Discord**: Join our community for real-time help - **Stack Overflow**: Tag questions with `pdf-watermark-generator-api` - **GitHub**: Report issues and request features - **Knowledge Base**: Common questions and solutions ### Updates & Changelog - **API Versioning**: Backwards-compatible updates - **Feature Announcements**: Email notifications for new features - **Migration Guides**: Help upgrading to new versions - **Beta Features**: Early access to new functionality --- **Transform your documents with professional watermarks today! 🎨** *Reliable, scalable, and developer-friendly PDF watermarking API.*