File Conversion for Web Agencies

Web agencies handle format conversion as part of every project. Client-provided images are in whatever format the client has — PSD, TIFF, PNG, HEIC. Web performance requires WebP or AVIF. Fonts licensed as TTF need to be WOFF2 for self-hosting. Video backgrounds need to be WebM for compatibility. These format conversion tasks are constant, they're not billable, and they don't require expensive software licenses if you have the right tool.

Format friction in web development projects

Web agencies encounter format conversion at every project phase:

• Client asset intake — clients deliver images in whatever they have: PSD, TIFF, PNG, HEIC, JPG at inconsistent resolutions. Before any of these go into the project, they need to be in web-ready formats at consistent quality settings.
• Image optimization for performance — Lighthouse scores, Core Web Vitals, and client performance expectations require modern image formats. PNG and JPG need to become WebP or AVIF. This is a conversion step that happens on every project before launch.
• Font format preparation — licensed fonts come as TTF or OTF. Self-hosting for performance requires WOFF2. Converting a font family (regular, bold, italic, bold-italic) is a conversion task that comes up on every custom typography project.
• Video asset preparation — client-provided video assets in MOV or MKV need to be MP4 for web video elements, or WebM for broader compatibility. Short background videos often need to be both.
• Document-to-image conversion — client PDFs need JPG page images for use as OG images, preview thumbnails in a page builder, or inline display without a PDF viewer.
• SVG rendering — SVG files from designers need to be PNG for use in contexts that don't support SVG (email, some CMS platforms, OG images).

Common format pairs for web agencies

The conversion routes web agencies use on every project:

• PNG → WebP / AVIF — the performance-critical conversion on almost every web project. Convert all static images before build.
• JPG → WebP — photography and product images for modern browser optimization
• PSD → JPG / PNG / WebP — extract Photoshop designs for web delivery without needing Creative Cloud
• HEIC → JPG — normalize client-provided iPhone photos before CMS upload
• TTF → WOFF2 — prepare licensed fonts for self-hosting with browser caching benefits
• OTF → WOFF2 — same as above for OpenType fonts
• SVG → PNG — render vector assets for contexts that don't support SVG
• MOV → MP4 / WebM — normalize client video assets for web video elements
• PDF → JPG — generate page images for OG images, thumbnails, and document previews
• GIF → MP4 / WebM — convert animated GIFs to video for smaller file size and better quality

The browser tool: fast asset checking without scripts

Image conversions at changethisfile.com run in the browser — PSD → PNG, PNG → WebP, JPG → WebP, SVG → PNG. For a developer checking conversion output quality before writing a build script, or a project manager converting a single client photo before CMS upload, the browser tool is the right choice.

Font conversions (TTF → WOFF2, OTF → WOFF2) require server-side processing. Video conversions (MOV → MP4) use FFmpeg on the server.

The browser tool works well for:

• QA checks — verify that a conversion route produces the expected quality before automating
• One-off asset prep during development without writing a script
• Client-facing demos — show a client what their assets will look like in a different format

API integration for build pipelines and CMS workflows

The endpoint is POST https://changethisfile.com/v1/convert. Source auto-detected from filename. No SDK needed — just curl, requests, or native fetch. Get a free API key.

Convert PNG to WebP for CDN

curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key" \
  -F "file=@hero_image.png" \
  -F "target=webp" \
  --output hero_image.webp

Convert a licensed font for self-hosting

curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key" \
  -F "file=@BrandFont-Regular.ttf" \
  -F "target=woff2" \
  --output BrandFont-Regular.woff2

Batch image optimization pre-deploy

# Convert all PNGs to WebP before CDN upload
for PNG in public/images/*.png; do
  BASE=$(basename "$PNG" .png)
  curl -sX POST https://changethisfile.com/v1/convert \
    -H "Authorization: Bearer $CTF_API_KEY" \
    -H "Idempotency-Key: project-${PROJECT_SLUG}-${BASE}" \
    -F "file=@${PNG}" \
    -F "target=webp" \
    -o "public/images/webp/${BASE}.webp"
done

Code example: CMS upload pipeline with format normalization

CMS asset handler: accept any image format from content editors, convert to WebP for storage, return the CDN URL. No SDK.

import requests
from pathlib import Path
from uuid import uuid4

CTF_API_KEY = "ctf_sk_your_key_here"
CDN_BASE_URL = "https://cdn.yourclient.com"

IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".psd", ".heic", ".heif",
              ".tiff", ".tif", ".bmp", ".gif", ".avif"}

def upload_to_cdn(file_path: str, filename: str) -> str:
    """Stub: upload file to CDN and return URL."""
    # Replace with your actual CDN upload logic
    return f"{CDN_BASE_URL}/{filename}"

def process_cms_image(upload_path: str, original_filename: str) -> str:
    """Convert uploaded image to WebP, upload to CDN, return URL."""
    ext = Path(original_filename).suffix.lower()
    stem = Path(original_filename).stem

    if ext in IMAGE_EXTS and ext != ".webp":
        # Convert to WebP
        with open(upload_path, "rb") as f:
            resp = requests.post(
                "https://changethisfile.com/v1/convert",
                headers={
                    "Authorization": f"Bearer {CTF_API_KEY}",
                    "Idempotency-Key": f"cms-{uuid4().hex[:8]}-{stem}",
                },
                files={"file": (original_filename, f)},  # source auto-detected
                data={"target": "webp"},
                timeout=30,
            )
        resp.raise_for_status()
        out_name = f"{stem}.webp"
        out_path = f"/tmp/{out_name}"
        with open(out_path, "wb") as f:
            f.write(resp.content)
    else:
        out_name = original_filename
        out_path = upload_path

    return upload_to_cdn(out_path, out_name)

JavaScript (fetch, no SDK) for a Next.js or Astro CMS route:

const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.psd', '.heic',
  '.tiff', '.tif', '.bmp', '.gif', '.avif']);

async function processCmsImage(fileBuffer, filename) {
  const ext = filename.slice(filename.lastIndexOf('.')).toLowerCase();
  if (!IMAGE_EXTS.has(ext) || ext === '.webp') {
    return { data: fileBuffer, filename };
  }

  const form = new FormData();
  form.append('file', new Blob([fileBuffer]), filename); // source auto-detected
  form.append('target', 'webp');

  const resp = await fetch('https://changethisfile.com/v1/convert', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${process.env.CTF_API_KEY}` },
    body: form,
  });
  if (!resp.ok) throw new Error(`${resp.status}: ${await resp.text()}`);
  return {
    data: Buffer.from(await resp.arrayBuffer()),
    filename: filename.replace(/\.[^.]+$/, '.webp'),
  };
}

curl for one-off font conversion:

curl -sX POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer $CTF_API_KEY" \
  -F "file=@CustomBrand-Bold.otf" \
  -F "target=woff2" \
  -o CustomBrand-Bold.woff2

Pricing for web agency scale

A project launch with 100 images (PNG → WebP) plus a font family (4 weights × TTF → WOFF2) plus 10 document conversions is roughly 114 conversions — free tier covers one project per month easily. Active agencies with automated CMS pipelines across multiple clients should use Hobby or Startup.

FAQ

Does TTF → WOFF2 conversion preserve font hinting and kerning?

TTF → WOFF2 conversion using fonttools preserves font metrics, hinting data, kerning, and OpenType features. WOFF2 is a compressed container format for TrueType and OpenType data — the font data itself isn't changed, just compressed. The rendered output is visually identical to the TTF.

Should I convert to WebP or AVIF for new projects?

Both are well-supported in modern browsers. WebP has wider compatibility including older Safari. AVIF generally achieves better compression ratios at equivalent quality but takes longer to encode. For most projects in 2026, WebP is the practical default; AVIF is worth the extra encoding time for photography-heavy sites where file size reduction is critical.

Can I use the API in a CI/CD pipeline?

Yes — the API is HTTP-based and works in any CI environment (GitHub Actions, GitLab CI, Vercel build hooks). Call it from a build step to convert assets before deployment. Idempotency keys prevent re-processing unchanged files on re-runs.

Does GIF → MP4 preserve the loop behavior?

GIF → MP4 conversion via FFmpeg produces an MP4 file. The MP4 format doesn't have native loop metadata — looping behavior is controlled by the HTML element (<video autoplay loop muted> attributes) rather than the file itself. Set loop in your HTML, not in the conversion parameters.

Can I convert SVG to PNG with transparency?

SVG → PNG preserves transparency — the PNG output has an alpha channel where the SVG had transparent areas. If you need a white background instead, that's an additional processing step not available in the conversion parameters currently.

Related guides

Guides for web development asset workflows: