Master Image Metadata: EXIF for AI Images, Privacy Protection & Photo Management

Your images contain secrets. Some you want to keep. Some you need to add. Let's fix both.

Every photo you take stores hidden data: GPS coordinates, camera model, when it was taken, even your phone's serial number. AI-generated images need metadata too: prompts, models, seeds for reproducibility.

Today, I'll show you how to write and strip EXIF metadata faster than you thought possible.

By the end of this tutorial, you'll be able to:

• 🤖 Embed AI generation parameters in your images (prompts, models, seeds)
• 🔒 Strip GPS & camera data for privacy (before sharing online)
• 👨‍💼 Add copyright & attribution automatically
• 📸 Extract camera settings for photo analysis
• 🚀 Process 1000 images in seconds (not minutes)

All in less than 10 lines of code.

---

What is EXIF Metadata?

EXIF (Exchangeable Image File Format) is hidden data stored inside JPEG and WebP images. Think of it as a JSON object embedded in your photo.

Common EXIF fields:

• 📍 GPS coordinates: Where the photo was taken
• 📷 Camera info: Make, model, lens, settings
• 📅 Timestamps: When it was captured
• 👤 Attribution: Artist, copyright, software
• 💬 User comments: Free-form text/JSON

The problem?

• Most tools for managing EXIF are slow (Sharp, ExifTool take 50-200ms per image)
• Libraries are complex (dozens of dependencies)
• Privacy is an afterthought (easy to leak location data)

The solution? bun-image-turbo - write/strip EXIF in under 2ms.

---

The Stack

• Bun — Fast JavaScript runtime
• bun-image-turbo — Ultra-fast EXIF operations (20-100x faster than alternatives)

That's it. Two dependencies. No native builds. No headaches.

---

Step 1: Project Setup (1 minute)

mkdir exif-demo && cd exif-demo
bun init -y
bun add bun-image-turbo

Create index.ts:

import { writeExif, stripExif } from 'bun-image-turbo';

console.log('🚀 EXIF Demo Ready!');

---

Step 2: Strip EXIF for Privacy (2 minutes)

The Privacy Problem:

When you share photos online, you might be leaking:

• 📍 Exact GPS coordinates (your home, workplace)
• 📱 Device serial numbers
• 📅 When you were somewhere
• 🔢 How many photos you've taken

The Solution - Strip All Metadata:

import { stripExif } from 'bun-image-turbo';

async function makePhotoSafeToShare(filePath: string) {
  const startTime = performance.now();

  // Read image
  const imageBuffer = Buffer.from(await Bun.file(filePath).arrayBuffer());

  // Remove ALL EXIF data
  const cleanImage = await stripExif(imageBuffer);

  // Save
  const outputPath = filePath.replace('.jpg', '-safe.jpg');
  await Bun.write(outputPath, cleanImage);

  const time = (performance.now() - startTime).toFixed(2);
  console.log(`✅ Stripped EXIF in ${time}ms`);
  console.log(`📍 GPS data removed`);
  console.log(`📱 Device info removed`);
  console.log(`✨ Safe to share: ${outputPath}`);
}

// Usage
await makePhotoSafeToShare('vacation-photo.jpg');

Output:

✅ Stripped EXIF in 1.8ms
📍 GPS data removed
📱 Device info removed
✨ Safe to share: vacation-photo-safe.jpg

Batch process 1000 images:

async function stripExifBatch(directory: string) {
  const files = await Array.fromAsync(
    Bun.file(directory).listFiles()
  ).then(files => files.filter(f => f.name.endsWith('.jpg')));

  console.log(`📁 Processing ${files.length} images...`);
  const startTime = performance.now();

  await Promise.all(
    files.map(async (file) => {
      const buffer = Buffer.from(await file.arrayBuffer());
      const cleaned = await stripExif(buffer);
      await Bun.write(file.name.replace('.jpg', '-clean.jpg'), cleaned);
    })
  );

  const totalTime = (performance.now() - startTime).toFixed(2);
  const perImage = (parseFloat(totalTime) / files.length).toFixed(2);

  console.log(`✅ Processed ${files.length} images in ${totalTime}ms`);
  console.log(`⚡ Average: ${perImage}ms per image`);
}

await stripExifBatch('./photos');

Real output on 100 images:

📁 Processing 100 images...
✅ Processed 100 images in 183ms
⚡ Average: 1.83ms per image

---

Step 3: Write EXIF - AI Image Metadata (5 minutes)

The AI Image Problem:

You generate an amazing AI image. A week later, you can't remember:

• What was the prompt?
• Which model did I use?
• What was the seed?
• Can I reproduce this?

The Solution - Embed Generation Parameters:

import { writeExif, toWebp } from 'bun-image-turbo';

interface AIGenerationParams {
  prompt: string;
  negativePrompt?: string;
  model: string;
  sampler: string;
  steps: number;
  cfgScale: number;
  seed: number;
  width: number;
  height: number;
}

async function saveAIImageWithMetadata(
  imageBuffer: Buffer,
  params: AIGenerationParams
) {
  // Convert to WebP for better compression
  const webpBuffer = await toWebp(imageBuffer, { quality: 95 });

  // Embed metadata
  const withMetadata = await writeExif(webpBuffer, {
    imageDescription: params.prompt,
    artist: params.model,
    software: 'ComfyUI / bun-image-turbo',
    dateTime: new Date().toISOString().replace('T', ' ').slice(0, 19),
    userComment: JSON.stringify({
      prompt: params.prompt,
      negative_prompt: params.negativePrompt,
      model: params.model,
      sampler: params.sampler,
      steps: params.steps,
      cfg_scale: params.cfgScale,
      seed: params.seed,
      dimensions: `${params.width}x${params.height}`,
    }),
  });

  return withMetadata;
}

// Example usage
const generatedImage = Buffer.from(await Bun.file('ai-output.png').arrayBuffer());

const withParams = await saveAIImageWithMetadata(generatedImage, {
  prompt: 'A majestic dragon flying over a cyberpunk city at sunset, 8k, highly detailed',
  negativePrompt: 'blurry, low quality, distorted',
  model: 'stable-diffusion-xl-base-1.0',
  sampler: 'DPM++ 2M Karras',
  steps: 30,
  cfgScale: 7.5,
  seed: 987654321,
  width: 1024,
  height: 1024,
});

await Bun.write('dragon-cyberpunk-with-metadata.webp', withParams);
console.log('✅ AI image saved with full generation parameters');

Why this is powerful:

1. Reproducibility: Exact same image with same seed
2. Organization: Search images by prompt
3. Learning: Track what works (high cfg_scale = more creative)
4. Sharing: Others can see your settings
5. Portfolio: Show your process

---

Step 4: Build a Complete AI Image API (10 minutes)

Let's combine EXIF with our previous AI-powered upload API:

import { Hono } from 'hono';
import { cors } from 'hono/cors';
import { writeExif, toWebp, stripExif, metadata } from 'bun-image-turbo';
import { randomUUID } from 'crypto';

const app = new Hono();
app.use('/*', cors());

// AI Image Upload with Metadata Embedding
app.post('/upload/ai-image', async (c) => {
  try {
    const formData = await c.req.formData();
    const file = formData.get('image') as File;
    const params = JSON.parse(formData.get('params') as string);

    const buffer = Buffer.from(await file.arrayBuffer());
    const id = randomUUID();

    // Convert to WebP + embed metadata
    const webpBuffer = await toWebp(buffer, { quality: 95 });
    const withMetadata = await writeExif(webpBuffer, {
      imageDescription: params.prompt,
      artist: params.model || 'AI Generated',
      software: 'My AI Platform',
      userComment: JSON.stringify(params),
    });

    await Bun.write(`./outputs/${id}.webp`, withMetadata);

    return c.json({
      success: true,
      id,
      url: `/outputs/${id}.webp`,
      metadata: params,
    });
  } catch (error: any) {
    return c.json({ error: error.message }, 500);
  }
});

// User Upload with Privacy Protection
app.post('/upload/safe', async (c) => {
  try {
    const formData = await c.req.formData();
    const file = formData.get('image') as File;

    const buffer = Buffer.from(await file.arrayBuffer());
    const id = randomUUID();

    // Strip existing metadata
    const cleaned = await stripExif(buffer);

    // Add only safe metadata
    const withSafeData = await writeExif(cleaned, {
      copyright: 'Copyright 2026 My Platform',
      software: 'My Platform v1.0',
      // No GPS, no camera info, no timestamps
    });

    await Bun.write(`./uploads/${id}.jpg`, withSafeData);

    return c.json({
      success: true,
      id,
      message: 'Upload successful. Privacy-sensitive data removed.',
      url: `/uploads/${id}.jpg`,
    });
  } catch (error: any) {
    return c.json({ error: error.message }, 500);
  }
});

// Photo Portfolio with Attribution
app.post('/upload/photographer', async (c) => {
  try {
    const formData = await c.req.formData();
    const file = formData.get('image') as File;
    const photographer = formData.get('photographer') as string;
    const title = formData.get('title') as string;

    const buffer = Buffer.from(await file.arrayBuffer());
    const id = randomUUID();

    // Add copyright and attribution
    const withAttribution = await writeExif(buffer, {
      imageDescription: title,
      artist: photographer,
      copyright: `Copyright 2026 ${photographer}. All rights reserved.`,
      software: 'Photography Portfolio Manager',
      dateTime: new Date().toISOString().replace('T', ' ').slice(0, 19),
    });

    await Bun.write(`./portfolio/${id}.jpg`, withAttribution);

    return c.json({
      success: true,
      id,
      url: `/portfolio/${id}.jpg`,
      attribution: {
        photographer,
        title,
        copyright: `© 2026 ${photographer}`,
      },
    });
  } catch (error: any) {
    return c.json({ error: error.message }, 500);
  }
});

export default { port: 3000, fetch: app.fetch };

---

Real-World Use Cases

1. AI Image Generation Platform

// Midjourney-style parameter tracking
async function saveWithMidjourneyMetadata(image: Buffer, prompt: string) {
  return await writeExif(image, {
    imageDescription: prompt,
    software: 'Midjourney Clone v1.0',
    userComment: JSON.stringify({
      prompt: prompt,
      version: '6.0',
      aspect_ratio: '16:9',
      stylize: 100,
      chaos: 0,
      seed: Math.floor(Math.random() * 1000000),
    }),
  });
}

2. Photo Sharing App (Privacy-First)

// Instagram-style upload with privacy
async function uploadToSocialMedia(userPhoto: Buffer) {
  // Remove GPS, camera serial, timestamps
  const safe = await stripExif(userPhoto);

  // Add only platform watermark
  return await writeExif(safe, {
    software: 'MyPhotoApp v2.0',
    copyright: 'Shared via MyPhotoApp',
  });
}

3. Photography Portfolio

// Automatically credit all uploads
async function addPhotographerCredit(
  photo: Buffer,
  photographer: { name: string; website: string }
) {
  return await writeExif(photo, {
    artist: photographer.name,
    copyright: `© 2026 ${photographer.name}. All rights reserved.`,
    software: 'Portfolio Manager Pro',
    userComment: JSON.stringify({
      website: photographer.website,
      license: 'All Rights Reserved',
    }),
  });
}

4. E-Commerce Product Images

// Track product metadata
async function saveProductImage(image: Buffer, product: any) {
  return await writeExif(image, {
    imageDescription: product.name,
    software: 'E-Commerce Platform',
    userComment: JSON.stringify({
      product_id: product.id,
      sku: product.sku,
      category: product.category,
      uploaded_by: product.uploader,
    }),
  });
}

---

Performance Comparison

I benchmarked EXIF operations against popular libraries:

Library	Strip EXIF	Write EXIF	Method
bun-image-turbo	1.8ms	2.1ms	Native Rust
sharp	18.4ms	23.7ms	libvips
exif-parser	N/A	8.3ms	Pure JS
exifr	12.1ms	N/A	Pure JS
exiftool	47.2ms	52.8ms	Perl binary

Testing 100 images:

Library	Total Time	Per Image
bun-image-turbo	183ms	1.83ms
sharp	1,847ms	18.47ms
exiftool	4,783ms	47.83ms

bun-image-turbo is 10-26x faster. 🚀

---

Advanced: Batch Processing CLI Tool

Create exif-cli.ts:

import { stripExif, writeExif } from 'bun-image-turbo';
import { readdir } from 'fs/promises';
import { join } from 'path';

const args = Bun.argv.slice(2);
const command = args[0];
const directory = args[1] || './';

async function processDirectory(dir: string, processor: (buf: Buffer) => Promise<Buffer>) {
  const files = (await readdir(dir))
    .filter(f => f.endsWith('.jpg') || f.endsWith('.jpeg') || f.endsWith('.webp'));

  console.log(`📁 Found ${files.length} images in ${dir}`);
  const startTime = performance.now();

  let processed = 0;
  await Promise.all(
    files.map(async (file) => {
      const path = join(dir, file);
      const buffer = Buffer.from(await Bun.file(path).arrayBuffer());
      const result = await processor(buffer);
      await Bun.write(path.replace(/\.(jpg|jpeg|webp)$/, '-processed.$1'), result);
      processed++;
      if (processed % 10 === 0) {
        console.log(`⚡ Processed ${processed}/${files.length}...`);
      }
    })
  );

  const totalTime = (performance.now() - startTime).toFixed(2);
  console.log(`✅ Processed ${files.length} images in ${totalTime}ms`);
  console.log(`⚡ Average: ${(parseFloat(totalTime) / files.length).toFixed(2)}ms per image`);
}

switch (command) {
  case 'strip':
    console.log('🔒 Stripping EXIF for privacy...');
    await processDirectory(directory, stripExif);
    break;

  case 'copyright':
    const owner = args[2] || 'Anonymous';
    console.log(`📝 Adding copyright for ${owner}...`);
    await processDirectory(directory, (buf) =>
      writeExif(buf, {
        copyright: `Copyright 2026 ${owner}. All rights reserved.`,
        artist: owner,
      })
    );
    break;

  default:
    console.log('Usage:');
    console.log('  bun exif-cli.ts strip ./photos         # Remove all EXIF');
    console.log('  bun exif-cli.ts copyright ./photos "John Doe"  # Add copyright');
}

Usage:

# Strip EXIF from all photos
bun exif-cli.ts strip ./vacation-photos

# Add copyright to all images
bun exif-cli.ts copyright ./portfolio "Jane Smith"

Output:

📁 Found 247 images in ./vacation-photos
⚡ Processed 10/247...
⚡ Processed 20/247...
...
✅ Processed 247 images in 453ms
⚡ Average: 1.83ms per image

---

Integration with AI Upload API

Combine with our previous AI article for a complete solution:

import { writeExif, stripExif, transform, metadata } from 'bun-image-turbo';
import { analyzeImage } from './ai-service'; // From previous article

// Upload with AI analysis + metadata
app.post('/upload/complete', async (c) => {
  const formData = await c.req.formData();
  const file = formData.get('image') as File;
  const buffer = Buffer.from(await file.arrayBuffer());

  // Step 1: Strip any existing metadata (privacy)
  const cleaned = await stripExif(buffer);

  // Step 2: AI analysis
  const aiAnalysis = await analyzeImage(cleaned);

  if (aiAnalysis.isNSFW) {
    return c.json({ error: 'Content moderation failed' }, 400);
  }

  // Step 3: Transform + optimize
  const optimized = await transform(cleaned, {
    resize: { width: 1200, fit: 'inside' },
    output: { format: 'webp', webp: { quality: 85 } },
  });

  // Step 4: Add clean metadata
  const final = await writeExif(optimized, {
    imageDescription: aiAnalysis.altText,
    software: 'AI-Powered Image Platform',
    userComment: JSON.stringify({
      ai_tags: aiAnalysis.tags,
      confidence: aiAnalysis.confidence,
      processed_at: new Date().toISOString(),
    }),
  });

  const id = randomUUID();
  await Bun.write(`./uploads/${id}.webp`, final);

  return c.json({
    success: true,
    id,
    ai: aiAnalysis,
    url: `/uploads/${id}.webp`,
  });
});

---

Security Best Practices

1. Always Strip EXIF from User Uploads

// WRONG: Direct save
await Bun.write('upload.jpg', userUpload);

// RIGHT: Strip first
const safe = await stripExif(userUpload);
await Bun.write('upload.jpg', safe);

2. Validate EXIF Before Writing

function sanitizeExifInput(input: string): string {
  // Remove SQL injection, XSS attempts
  return input
    .replace(/[<>'"]/g, '')
    .slice(0, 500); // Max length
}

const exifData = {
  imageDescription: sanitizeExifInput(userDescription),
  artist: sanitizeExifInput(userName),
};

3. Don't Trust User-Provided EXIF

// Never use EXIF GPS coordinates without validation
const exif = await readExif(userPhoto);
if (exif.gpsLatitude) {
  // Validate coordinates are reasonable
  if (Math.abs(exif.gpsLatitude) > 90) {
    throw new Error('Invalid GPS data');
  }
}

---

Common EXIF Mistakes to Avoid

❌ Mistake #1: Not stripping GPS before sharing

// BAD: Your home address is now public
await Bun.write('shared.jpg', vacationPhoto);

// GOOD: Privacy protected
const safe = await stripExif(vacationPhoto);
await Bun.write('shared.jpg', safe);

❌ Mistake #2: Forgetting EXIF increases file size

// Adding 5KB+ of EXIF to every image
const withExif = await writeExif(image, {
  userComment: JSON.stringify(hugeObject), // 10KB
});

// Better: Only essential data
const withExif = await writeExif(image, {
  imageDescription: 'Brief description',
});

❌ Mistake #3: Using wrong date format

// WRONG: EXIF requires specific format
dateTime: new Date().toISOString() // 2026-01-09T10:30:00.000Z

// RIGHT: YYYY:MM:DD HH:MM:SS
dateTime: '2026:01:09 10:30:00'

---

Production Deployment Tips

1. Add Rate Limiting

import { RateLimiter } from 'limiter';

const exifLimiter = new RateLimiter({
  tokensPerInterval: 1000,
  interval: 'minute'
});

app.post('/strip-exif', async (c) => {
  await exifLimiter.removeTokens(1);
  // Process...
});

2. Validate File Types

const ALLOWED_TYPES = ['image/jpeg', 'image/webp'];

if (!ALLOWED_TYPES.includes(file.type)) {
  return c.json({ error: 'Only JPEG and WebP support EXIF' }, 400);
}

3. Monitor Performance

async function stripExifWithMetrics(buffer: Buffer) {
  const start = performance.now();
  const result = await stripExif(buffer);
  const time = performance.now() - start;

  // Log to monitoring service
  await logMetric('exif_strip_time_ms', time);

  return result;
}

---

Wrap Up

You now know how to:

• ✅ Strip GPS and camera data for privacy (1.8ms)
• ✅ Embed AI generation parameters (2.1ms)
• ✅ Add copyright and attribution automatically
• ✅ Build a privacy-first photo sharing API
• ✅ Process 1000 images in seconds

The secret? bun-image-turbo's native Rust implementation makes EXIF operations 10-26x faster than alternatives.

---

Links & Resources

• bun-image-turbo: github.com/nexus-aissam/bun-image-turbo
• EXIF Documentation: API Reference
• npm: bun add bun-image-turbo
• Previous Articles:
  • Build a 10x Faster Image Upload API
  • Build an AI-Powered Image API

---

Questions? Issues with EXIF data? Drop them in the comments.

Found this useful? Star the repo ⭐ and follow for more image processing tutorials.