File Conversion for Insurance

Insurance operations deal with format conversion at every stage of the claims lifecycle. Policyholders submit photos of damaged property from their iPhones — HEIC. Adjusters document site visits with photos that need to be in a specific format before upload to the claims management system. Policy documents and endorsements are drafted in Word and need to be non-editable PDFs for delivery. Claims data exported from the system needs to be CSV before it can be analyzed. These are format conversion problems that repeat on every claim.

Format friction in insurance operations

Insurance teams encounter format conversion in claims, policy administration, and operations:

• Claim photo intake — policyholders and field adjusters submit damage photos from smartphones. iPhones default to HEIC. The claims management platform requires JPG. Every auto, property, and liability claim involves at least a few photos that need format conversion before upload.
• Policy document delivery — policy jackets, endorsements, and declarations pages are often templated in DOCX and need to be PDF for delivery to policyholders via email, portal, or print. PDF ensures consistent layout and is the expected format for insurance documents.
• Adjuster documentation — field adjusters compile reports in DOCX with embedded damage photos. These need to be converted to PDF for the claims file. The PDF creates a non-editable record of the adjuster's findings.
• Claims data analysis — XLSX exports from claims management systems need to be CSV for actuarial analysis, loss ratio calculations, and BI tool ingestion.
• Regulatory filings — rate filings, form submissions, and regulatory correspondence need to be in specific formats (often PDF) for state insurance department submission.

Common format pairs in insurance

The conversion routes insurance teams use most:

• HEIC → JPG — policyholder and adjuster damage photos for claims management system upload
• DOCX → PDF — policies, endorsements, declarations pages, adjuster reports, and correspondence for distribution and claims files
• XLSX → CSV — claims data, loss runs, and actuarial datasets for analysis pipelines and BI tools
• PDF → JPG — generate page previews of policy documents and claim files for web-based claims platforms
• PPTX → PDF — underwriting presentations, product briefs, and training materials
• PNG → JPG — screenshots and diagram-based damage documentation
• TIFF → JPG — scanned paper claims forms and legacy document archives
• XLSX → PDF — loss summaries, billing statements, and financial exhibits for policyholder or broker delivery

The browser tool: claim photos without upload

HEIC → JPG and other image conversions run entirely in the browser at changethisfile.com — claim photos are processed locally and never uploaded to a server. For adjusters or claims coordinators converting policyholder-submitted photos, this is the privacy-appropriate approach for ad hoc conversions.

Document conversions (DOCX → PDF, PPTX → PDF) require server-side processing via LibreOffice, with auto-delete after conversion.

The browser tool is appropriate for:

• Adjusters converting photos during a field visit or review
• Claims coordinators converting individual documents before upload
• Quick XLSX → CSV exports during data analysis

API integration for claims platforms

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

Normalize a claim photo on submission

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

Convert adjuster report to PDF

curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key" \
  -H "Idempotency-Key: claim-${CLAIM_NUMBER}-adjuster-report" \
  -F "file=@adjuster_report_claim_${CLAIM_NUMBER}.docx" \
  -F "target=pdf" \
  --output adjuster_report_claim_${CLAIM_NUMBER}.pdf

Export claims data to CSV

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

Code example: claim submission photo and document normalization

Claims intake webhook: when a policyholder submits a claim, normalize all uploaded files before storing in the claims platform. No SDK.

import requests
from pathlib import Path

CTF_API_KEY = "ctf_sk_your_key_here"

IMAGE_EXTS = {".heic", ".heif", ".tiff", ".tif", ".png", ".bmp"}
DOC_EXTS = {".docx", ".doc", ".odt", ".rtf"}

def normalize_claim_upload(upload_path: str, original_filename: str,
                           claim_number: str) -> tuple[bytes, str]:
    """Normalize claim photo or document for claims management system."""
    p = Path(original_filename)
    ext = p.suffix.lower()

    if ext in IMAGE_EXTS:
        target, out_ext = "jpg", "jpg"
    elif ext in DOC_EXTS:
        target, out_ext = "pdf", "pdf"
    else:
        with open(upload_path, "rb") as f:
            return f.read(), original_filename

    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"claim-{claim_number}-{p.stem}",
            },
            files={"file": (original_filename, f)},  # source auto-detected
            data={"target": target},
            timeout=60,
        )
    resp.raise_for_status()
    return resp.content, f"{p.stem}.{out_ext}"

JavaScript (fetch, no SDK):

const IMAGE_EXTS = new Set(['.heic', '.heif', '.tiff', '.tif', '.png', '.bmp']);
const DOC_EXTS = new Set(['.docx', '.doc', '.odt', '.rtf']);

async function normalizeClaimUpload(fileBuffer, filename, claimNumber) {
  const ext = filename.slice(filename.lastIndexOf('.')).toLowerCase();
  let target;
  if (IMAGE_EXTS.has(ext)) target = 'jpg';
  else if (DOC_EXTS.has(ext)) target = 'pdf';
  else return { data: fileBuffer, filename };

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

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

curl for adjuster use:

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

Pricing for insurance team scale

A claims team processing 200 claims per month with 5 photos and 2 documents each is roughly 1,400 conversions — the Hobby plan covers this comfortably. Larger operations with automated intake pipelines should use Startup or Scale.

FAQ

Do claim photos need any processing beyond format conversion?

Format conversion handles the file type compatibility issue. Metadata (GPS location, timestamp) embedded in the photo EXIF data is preserved in the JPG output. If your claims platform needs GPS coordinates from photos for automated location verification, the EXIF data survives the HEIC → JPG conversion.

Can the API handle high-volume claim submission bursts (after a storm event)?

For burst events, higher-tier plans have better concurrency handling. For very high-volume bursts (thousands of claims simultaneously), use async mode with webhooks so individual conversions queue rather than timing out. Pre-scale your plan before a known event if possible.

Does DOCX → PDF preserve digital signatures in adjuster reports?

Standard DOCX → PDF conversion via LibreOffice renders the visual content of the document, including digital signature images if they're embedded as images. Cryptographically signed DOCX documents (with XML Digital Signatures) do not transfer their signature validity to PDF — the PDF is a new document. For legally binding electronic signatures, use your e-signature platform's PDF output directly.

Can I attach converted photos directly to a claims management system?

The API returns the converted file in the HTTP response. Your code receives the bytes and can then upload to whatever storage system your claims platform uses (S3, Azure Blob, direct API). The API doesn't have native connectors to specific claims platforms.

What about converting scanned paper claims forms (TIFF) to searchable PDF?

TIFF → PDF is supported and produces a PDF. For searchable PDFs (where the text is recognized and selectable), you'd need OCR processing, which is a separate step from format conversion. The API converts the format; it doesn't perform OCR.

Related guides

Conversion guides for insurance documentation workflows: