File Conversion for SaaS Products

File conversion is a feature, not a business. Most SaaS teams learn this the hard way: they install FFmpeg in their Dockerfile, hit a corrupt-file edge case that crashes a worker, spend two sprints hardening it, and still get a support ticket about HEIC files not converting on their customer's iPhone photos. The cleaner path is to treat conversion like you treat email delivery or payments — outsource the operational complexity and focus on your product.

Where file conversion appears in SaaS products

Conversion requirements sneak into SaaS products at several points:

• Import flows — accept XLSX, CSV, or XML uploads from customers who have data in existing tools
• Export features — let users download their data as PDF reports, CSV exports, or ZIP archives
• Document management — normalize DOCX/PPTX uploads to PDF for consistent preview rendering
• Media handling — convert customer-uploaded videos to web-friendly formats, images to WebP
• Onboarding migrations — help new customers convert files from legacy tools (XLS → XLSX, DOC → DOCX, MP3 → M4A)
• Compliance output — generate PDF/A or accessible PDF versions of documents for audit trails

In each case, the conversion is a supporting feature — not what your product is about. The question is whether you want to own the infrastructure that makes it work.

Common format pairs in SaaS workflows

The pairs that come up most in SaaS product requirements:

• DOCX / DOC → PDF — normalize uploaded contracts, proposals, or reports to PDF for preview and storage
• PPTX / PPT → PDF — export presentations to share with non-PowerPoint users
• XLSX / XLS → CSV — parse customer data uploads without requiring Excel-aware parsers
• CSV → XLSX — generate formatted Excel exports for customers who prefer spreadsheets
• HEIC → JPG — handle iOS photo uploads across your product
• PNG / JPG → WebP — optimize stored images before CDN delivery
• MP4 / MOV → WebM / MP4 — transcode customer video uploads for browser playback
• JSON → CSV / XLSX — data export feature for analytics or reporting sections

Testing conversions before you build

Before writing integration code, validate the specific format pair at changethisfile.com. Upload a representative sample of your customers' files — not just clean test files. The browser tool processes real files with the same engine the API uses. This catches edge cases (protected Word docs, multi-sheet XLS files, unusual MP4 codecs) before they surface in production.

Image, data, and font conversions run client-side — files stay in your browser. Document and video conversions upload to the server and are auto-deleted after processing.

Multi-tenant usage tracking

For SaaS products that want to track conversions by customer or pass through usage costs, the API supports customer-scoped requests. Tag each request with your customer's identifier in a metadata header — this flows through to your billing dashboard.

import requests
from pathlib import Path

CTF_API_KEY = "ctf_sk_your_key_here"

def convert_for_customer(
    file_path: str,
    target: str,
    customer_id: str,
    idempotency_key: str,
) -> bytes:
    """Convert a file and tag the request with the customer ID for usage tracking.
    `source` is auto-detected from the filename extension.
    """
    with open(file_path, "rb") as f:
        resp = requests.post(
            "https://changethisfile.com/v1/convert",
            headers={
                "Authorization": f"Bearer {CTF_API_KEY}",
                "Idempotency-Key": idempotency_key,
                "X-Customer-Id": customer_id,
            },
            files={"file": (Path(file_path).name, f)},
            data={"target": target},
            timeout=60,
        )
    resp.raise_for_status()
    return resp.content

Usage-based billing integration

If your SaaS charges customers for conversions, track usage against your own metering system. The idempotency key prevents double-counting on retries:

from uuid import uuid4
import your_billing_module as billing

def metered_convert(file_path, target, customer_id):
    idem_key = f"conv-{customer_id}-{uuid4()}"
    result = convert_for_customer(file_path, target, customer_id, idem_key)
    # Record usage only after successful conversion
    billing.record_usage(customer_id, event="file_conversion", idempotency_key=idem_key)
    return result

Code example: DOCX → PDF for document preview

A common SaaS pattern: customers upload DOCX contracts or reports. You convert to PDF for inline preview, store the PDF alongside the original. Plain fetch — no SDK required.

interface UploadResult {
  originalKey: string;
  previewKey: string;
  customerId: string;
}

const CTF_API_KEY = process.env.CTF_API_KEY!;

async function processDocumentUpload(
  file: Buffer,
  fileName: string,
  customerId: string,
  storage: StorageClient,
): Promise {
  const ext = fileName.split(".").pop()!.toLowerCase();
  const baseKey = `customers/${customerId}/docs/${Date.now()}`;

  // Store original
  await storage.put(`${baseKey}.${ext}`, file);

  // Only convert document formats — skip if already PDF
  if (["docx", "doc", "odt", "rtf"].includes(ext)) {
    const form = new FormData();
    form.append("file", new Blob([file]), fileName);  // source auto-detected from filename
    form.append("target", "pdf");

    const r = await fetch("https://changethisfile.com/v1/convert", {
      method: "POST",
      headers: {
        Authorization: `Bearer ${CTF_API_KEY}`,
        "Idempotency-Key": `preview-${customerId}-${Date.now()}`,
      },
      body: form,
    });
    if (!r.ok) throw new Error(`${r.status} ${await r.text()}`);

    const pdfBuffer = Buffer.from(await r.arrayBuffer());
    await storage.put(`${baseKey}-preview.pdf`, pdfBuffer);
    return {
      originalKey: `${baseKey}.${ext}`,
      previewKey: `${baseKey}-preview.pdf`,
      customerId,
    };
  }

  return { originalKey: `${baseKey}.${ext}`, previewKey: "", customerId };
}

Pricing at SaaS scale

SaaS products typically fall into the Hobby or Startup tier based on active customer count:

At $99/mo for 50K conversions, the unit cost is $0.002/conversion — cheaper than the engineering time to handle one production incident with your own LibreOffice instance.

FAQ

Can we white-label the conversion output?

The API returns raw file bytes — no ChangeThisFile branding appears in output files. You can present the conversion feature under your own product name. The only constraint is that you can't resell raw API access as your own conversion API.

How do we handle tenant isolation for file data?

Files are processed in isolated temporary directories and deleted immediately after conversion. No cross-tenant file access is possible. The API doesn't store files beyond the conversion duration.

What happens when we exceed our plan limit?

You'll receive a 429 response with a Retry-After header. Upgrade your plan through the dashboard to continue. For burst traffic (e.g., a large customer onboarding), consider upgrading preemptively or implementing a queue with retry logic on 429s.

Do you offer SLAs?

Startup and above plans include an uptime commitment. The API runs on Cloudflare Workers (edge routing) with the conversion backend on dedicated infrastructure. Check the status page before integrating for any planned maintenance.

Can we track conversions per customer in our billing system?

Yes — use the X-Customer-Id header for tagging, and implement your own usage metering. The idempotency key pattern prevents double-counting on retries. See the code example above.

Is there a webhook for async conversions?

Yes. For long conversions (video transcoding, large documents), submit with async=true and a webhook_url. The webhook payload is HMAC-signed — verify the X-CTF-Signature header before processing.

Related guides

Common conversion tasks in SaaS products: