File Conversion for Healthcare: Patient Docs, Medical Images & HIPAA-Conscious Workflows

Healthcare document workflows involve a consistent set of format friction points. Patients submit photos of ID or insurance cards as HEIC from iPhones. Scanned intake forms arrive as TIFF or multi-page PDF. Clinical notes drafted in Word need to become PDF before EHR upload. Lab export data lives in XLSX but the analytics pipeline needs CSV. Each conversion step is small, but collectively they add up — and when HIPAA governs the handling of the underlying files, the infrastructure you use to convert them matters.

The format friction in healthcare operations

Healthcare teams encounter format conversion needs at several points in patient and administrative workflows:

Patient-submitted documents — insurance cards, ID photos, and prior authorization documents arrive in whatever format the patient's device produces. iPhones default to HEIC. Android devices produce JPG or PNG. Scanned documents from fax are TIFF. Your intake platform probably expects JPG or PDF.
Clinical documentation — templates and notes drafted in DOCX need to be PDF before uploading to an EHR or sending to referring providers. The PDF preserves formatting and is non-editable.
Referral and discharge packets — PPTX education materials, DOCX discharge instructions, and XLSX medication tables all need to be PDF for patient-facing handoff or portal upload.
Lab and operational data — XLSX exports from lab systems, scheduling software, or billing platforms need to become CSV for import into analytics tools or population health platforms.
Consent form preparation — DOCX consent templates need to be PDF before being sent for e-signature or printed for in-person signing.

None of this requires DICOM-level medical imaging software. It's document and image format conversion — the same class of problem that exists in every industry, with additional care around data handling.

Common format pairs in healthcare workflows

The format routes healthcare teams use most:

HEIC → JPG — normalize iPhone photos of insurance cards, wound documentation, and patient ID for intake platforms and EHR attachment
DOCX → PDF — finalize clinical notes, consent forms, discharge instructions, and referral letters for EHR upload or secure send
DOC → PDF — legacy document templates from older systems
PPTX → PDF — patient education slide decks for portal delivery
XLSX → CSV — export lab data, scheduling exports, and billing extracts for analytics pipelines
XLSX → PDF — medication lists, care plans, and summary tables for patient handoff
PDF → JPG — generate preview images of documents for inline display in care coordination platforms
PNG → JPG — compress screenshot-heavy clinical documentation for storage efficiency
TIFF → PDF — convert fax-received scanned forms into searchable PDFs
RTF → PDF — older dictation and transcription output formats

The browser tool: client-side conversion for sensitive images

Image conversions at changethisfile.com run entirely in the browser — HEIC → JPG, PNG → JPG, JPG → PDF. Files are processed locally by the browser and never uploaded. For a healthcare team normalizing patient-submitted photos in a zero-upload context, this is the privacy-appropriate approach.

Document conversions (DOCX → PDF, XLSX → CSV) require server-side processing and do involve a file upload. Files are auto-deleted after conversion. For regulated environments where server-side handling of PHI isn't appropriate, limit server-side conversions to non-PHI administrative documents, or use the API within infrastructure that satisfies your organization's HIPAA technical safeguard requirements.

The browser tool works well for:

Ad hoc photo normalization by clinical staff (HEIC → JPG without installing software)
One-off document conversions during intake or referral workflows
Testing conversion output quality before building an API integration

API integration for healthcare document pipelines

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

Convert a patient document to PDF

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

Normalize a patient photo upload

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

Idempotency for reliable processing

Use Idempotency-Key when retrying failed conversions — the same key within 24 hours returns the cached result without re-processing or double-billing.

curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key" \
  -H "Idempotency-Key: patient-intake-${PATIENT_ID}-${DOC_TYPE}" \
  -F "file=@discharge_summary.docx" \
  -F "target=pdf" \
  --output discharge_summary.pdf

Code example: normalize patient intake uploads

A common pattern: a patient portal accepts file uploads in any format. Before storing in the EHR, normalize images to JPG and documents to PDF. This runs on the server at upload time. Plain requests — no SDK.

import requests
from pathlib import Path

CTF_API_KEY = "ctf_sk_your_key_here"

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

def normalize_for_ehr(upload_path: str, original_filename: str) -> tuple[bytes, str]:
    """
    Normalize an uploaded file to JPG (images) or PDF (documents).
    Returns (converted_bytes, output_filename).
    """
    p = Path(original_filename)
    ext = p.suffix.lower()

    if ext in IMAGE_EXTS:
        target = "jpg"
        out_name = p.stem + ".jpg"
    elif ext in DOC_EXTS:
        target = "pdf"
        out_name = p.stem + ".pdf"
    else:
        # Already JPG, PDF, etc. — return as-is
        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}"},
            files={"file": (original_filename, f)},  # source auto-detected
            data={"target": target},
            timeout=60,
        )
    resp.raise_for_status()
    return resp.content, out_name

JavaScript (fetch, no SDK):

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

async function normalizeForEhr(fileBuffer, originalFilename) {
  const ext = originalFilename.slice(originalFilename.lastIndexOf('.')).toLowerCase();
  let target, outName;

  if (IMAGE_EXTS.has(ext)) {
    target = 'jpg';
    outName = originalFilename.replace(/\.[^.]+$/, '.jpg');
  } else if (DOC_EXTS.has(ext)) {
    target = 'pdf';
    outName = originalFilename.replace(/\.[^.]+$/, '.pdf');
  } else {
    return { data: fileBuffer, filename: originalFilename };
  }

  const form = new FormData();
  form.append('file', new Blob([fileBuffer]), originalFilename); // 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}` },
    body: form,
  });
  if (!resp.ok) throw new Error(`Conversion failed: ${resp.status}`);
  return { data: Buffer.from(await resp.arrayBuffer()), filename: outName };
}

curl example for a single document:

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

Pricing for healthcare team scale

Plan	Conversions/month	Price	Fits
Free	1,000	$0	Pilot or low-volume evaluation
Hobby	10,000	$29/mo	Small practice with a few hundred patient encounters per month
Startup	50,000	$99/mo	Mid-size clinic, health tech startup, or care coordination platform
Scale	500,000	$499/mo	Hospital system, telehealth platform, or high-volume intake workflow
Growth	5,000,000	$1,999/mo	Enterprise health system or platform serving many provider organizations

A clinic seeing 200 patients per month with 3-4 documents per encounter is around 600-800 conversions per month — comfortably within the free tier for evaluation and the Hobby plan for production use.

FAQ

Is ChangeThisFile HIPAA-compliant?

ChangeThisFile does not currently offer a BAA (Business Associate Agreement). If your use case involves PHI and requires a BAA, evaluate whether client-side conversion (images stay in the browser, never uploaded) is sufficient for your needs, or consult your compliance team about server-side conversion workflows. File uploads for server-side conversions are deleted after processing.

Can I convert scanned TIFF documents from fax?

Yes — TIFF → PDF is supported. Multi-page TIFFs convert to multi-page PDFs. For very large scanned files, use async mode to avoid timeout issues.

What about DICOM medical imaging files?

DICOM is not supported. DICOM conversion requires specialized medical imaging software (dcm4che, Orthanc, etc.) that handles the specific metadata and imaging data in DICOM files. ChangeThisFile handles common document and consumer image formats, not DICOM.

Can I convert audio recordings of patient visits?

Audio format conversions are supported (MP3, WAV, M4A, OGG). If you need to convert recorded audio for archival, transcription pipeline ingestion, or playback compatibility, audio-to-audio routes are available. Transcription (speech-to-text) is not a conversion route — that's a different service.

How does the auto-delete work?

Files uploaded for server-side conversion are stored temporarily in a secure temporary directory and deleted after the conversion completes. There is no persistent storage of uploaded file content. The conversion result is returned in the HTTP response and not retained.

Conversion guides relevant to healthcare document workflows: