File Conversion for News and Publishing

Publishing operations deal with format conversion at every stage of the content lifecycle. Photos come from wire services, freelancers, and phones — each in different formats at different resolutions. Video clips from the field are in whatever format the camera or phone produced, and web playback needs a specific codec. Long-form content needs EPUB for digital distribution alongside the web version. Print editions require high-res PDFs. Each step is a format conversion problem, and the faster it resolves, the faster stories ship.

Format friction in editorial workflows

Newsrooms and publishing teams encounter format conversion at multiple editorial touchpoints:

• Photo desk operations — wire service photos in TIFF, freelancer submissions in RAW, and staff photos in HEIC all need to be normalized to JPG or WebP before upload to the CMS. Photo editors spend real time on format conversion that should be automated.
• Video for web — field footage in MOV or MKV needs to be MP4 for web playback. Short clips for social need GIF or short MP4. Archival footage in older formats (AVI, WMV) needs to be converted for modern web players.
• Digital publishing — long-form articles, special reports, and ebooks require EPUB output. Print PDFs don't translate cleanly to EPUB; the source needs to be in a format that can be converted properly.
• Archive and print — PDFs for print edition archival, PPTX editorial presentations, and DOCX reports need consistent format handling for institutional document management.
• Multimedia asset handoffs — editorial designers, social teams, and syndication partners all have different format requirements for the same underlying content.

Common format pairs in editorial workflows

The conversion routes newsrooms and publishers use most:

• HEIC → JPG — staff and freelancer photos from iPhones normalized for CMS upload
• TIFF → JPG — high-res wire photos and archival scans reduced for web delivery
• PNG → WebP / JPG — screenshot-based editorial graphics for web optimization
• MOV → MP4 — iPhone and Mac camera video normalized for web playback
• AVI / WMV → MP4 — archival video formats converted for modern web players
• MP4 → GIF — short clips converted to GIF for email newsletters or social previews
• DOCX → PDF — editorial reports, style guides, and long-form drafts for PDF distribution
• EPUB → PDF — ebook layouts converted to PDF for print-on-demand or review
• PPTX → PDF — editorial presentations and pitch decks for stakeholder review
• SVG → PNG — data visualization and infographic vectors rendered for CMS upload

The browser tool: photo desk use without upload

Image conversions at changethisfile.com run in the browser — HEIC → JPG, TIFF → JPG, PNG → WebP. For photo editors handling wire and freelancer submissions, the browser tool provides a fast, no-install, no-upload conversion option. Drag and drop, get the converted file, upload to the CMS.

Video conversions (MOV → MP4, AVI → MP4) require server-side processing — files are uploaded, converted via FFmpeg, and auto-deleted.

The browser tool is the right choice for:

• Photo desk quick conversions without requiring software installation
• Ad hoc document exports during deadline workflows
• Freelancers and contributors who need to convert before submission

API integration for CMS and publishing pipelines

The endpoint is POST https://changethisfile.com/v1/convert. Source auto-detected from filename — pass file and target. No SDK needed. Get a free API key.

Normalize a wire photo on ingest

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

Convert field video for web

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

Async conversion for large video files

curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key" \
  -F "file=@documentary_segment.mov" \
  -F "target=mp4" \
  -F "async=true" \
  -F "webhook_url=https://cms.yourpublication.com/webhooks/ctf"
# Returns: {"job_id": "job_abc123", "status": "queued"}

Code example: normalize photo uploads on CMS ingest

CMS photo intake pipeline: accept any image format from contributors and normalize to JPG before CDN storage. No SDK — plain requests and fetch.

import requests
from pathlib import Path
from uuid import uuid4

CTF_API_KEY = "ctf_sk_your_key_here"

# Formats normalized to JPG for CMS storage
PHOTO_NORMALIZE = {".heic", ".heif", ".tiff", ".tif", ".bmp", ".png", ".webp"}

def normalize_editorial_photo(upload_path: str, original_filename: str) -> tuple[bytes, str]:
    """Normalize submitted photo to JPG for CMS."""
    ext = Path(original_filename).suffix.lower()

    if ext not in PHOTO_NORMALIZE:
        with open(upload_path, "rb") as f:
            return f.read(), original_filename

    story_id = uuid4().hex[:8]
    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"photo-{story_id}-{Path(original_filename).stem}",
            },
            files={"file": (original_filename, f)},  # source auto-detected
            data={"target": "jpg"},
            timeout=30,
        )
    resp.raise_for_status()
    out_name = Path(original_filename).stem + ".jpg"
    return resp.content, out_name

JavaScript fetch (no SDK):

const PHOTO_NORMALIZE = new Set(['.heic', '.heif', '.tiff', '.tif', '.bmp', '.png', '.webp']);

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

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

  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(/\.[^.]+$/, '.jpg'),
  };
}

curl one-liner for photo desk use:

curl -sX POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer $CTF_API_KEY" \
  -F "file=@reuters_photo.tiff" \
  -F "target=jpg" \
  -o reuters_photo.jpg

Pricing for publishing scale

A daily publication posting 10 stories with 3 photos each is 300 photo conversions per week — 1,200/month. Hobby plan covers this with room to spare. Newsrooms handling video alongside photos should start at Startup.

FAQ

Does the API support TIFF images from professional wire services at high resolution?

Yes — TIFF → JPG handles high-resolution wire photos. Large TIFF files may take longer to convert; for files over 25MB (free plan limit), a paid plan with higher size limits is required.

Can I convert DOCX articles to EPUB for Kindle distribution?

DOCX → EPUB is supported via Calibre. The conversion works well for long-form text content. For publications with complex layouts (sidebars, pull quotes, specialized formatting), EPUB output may require editorial review — Calibre's EPUB output is best for text-primary content.

What about converting INDD (InDesign) files?

InDesign format (INDD) is not supported. InDesign source files require the full InDesign application for export. The typical publishing workflow is to export from InDesign to PDF or IDML first, then use that as the conversion source.

Can I convert archival WMV video to MP4?

Yes — WMV → MP4 is supported via FFmpeg. Archival video files in legacy formats (WMV, AVI, FLV) convert cleanly to MP4. For very large archival files, use async mode with webhooks.

Is there a way to batch convert an entire photo archive?

The API doesn't have a batch endpoint. Use a script that sends requests in parallel (see the bash and Python examples) for bulk conversions. Parallelizing 5-10 requests at a time is appropriate for Startup and above plans.

Related guides

Guides for editorial and publishing workflows: