File Conversion for Scientific Research

Research workflows generate format conversion needs that are specific and reproducible. Every analysis pipeline has a preferred input format. Every journal submission has specific file requirements. Collaborators on different operating systems produce documents in different formats. Lab equipment exports data in proprietary or specialized formats that need transformation before analysis. These are format conversion problems — not scientific problems — and they shouldn't consume research time.

Format friction in research workflows

Research teams encounter format conversion at every stage of the data lifecycle:

• Data pipeline compatibility — equipment exports CSV with inconsistent delimiters; R prefers TSV; Python scripts expect JSON; PostgreSQL import needs clean CSV. Getting data into the right format before analysis is a conversion step that happens repeatedly.
• Instrument and imaging data — microscopy images, field cameras, and research devices often produce RAW or TIFF files. Publication figures need TIFF at 300 DPI (for print) or JPG/PNG (for web supplementary materials). Lab presentations need images that display in slides without requiring specialized software.
• Manuscript preparation — drafts live in DOCX through the writing and revision process. Journal submission systems often accept PDF only, or require specific format specifications for figures and supplementary materials.
• Data sharing and archival — research data for repositories (figshare, Dryad, Zenodo) needs to be in open, accessible formats. XLSX files shared for collaboration need CSV or JSON versions for programmatic access by others.
• Presentation preparation — conference presentations in PPTX need to be PDF for proceedings submissions or accessible sharing.

Common format pairs in research

The conversion routes researchers rely on:

• CSV → JSON — convert tabular data to JSON for API responses, NoSQL ingestion, or language-agnostic data exchange
• JSON → CSV — flatten JSON API responses or structured data exports to tabular format for analysis in R, Python, or Excel
• XLSX → CSV — export data from collaborative Excel files to clean CSV for analysis pipelines
• CSV → XLSX — share analysis output with collaborators or stakeholders who need spreadsheet format
• YAML → JSON / JSON → YAML — convert configuration and structured data files between formats
• TIFF → JPG / PNG — convert high-bit microscopy images to publication-appropriate web formats
• HEIC → JPG — normalize field photos from iOS devices for lab records and supplementary materials
• DOCX → PDF — manuscript finalization for journal submission, preprint servers, and institutional repositories
• PPTX → PDF — conference presentations for proceedings and accessible sharing
• EPUB → PDF — access ebooks and textbooks in print-friendly format

The browser tool: data files stay local

CSV ↔ JSON, XLSX → CSV, JSON ↔ YAML, and XML ↔ JSON conversions all run client-side at changethisfile.com. Research data files are processed in the browser and never uploaded. For researchers working with sensitive datasets (participant data, proprietary results, embargoed data), this is the appropriate approach for ad hoc conversions.

Image conversions (TIFF → JPG, HEIC → JPG) also run client-side for most formats. Document conversions (DOCX → PDF, PPTX → PDF) require server-side processing via LibreOffice, with auto-delete after conversion.

The browser tool is ideal for:

• Quick data format conversion during analysis setup
• One-off manuscript PDF before submission
• Image format conversion for publication figures

API integration for automated research pipelines

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

Convert a CSV dataset to JSON

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

Convert XLSX collaborative data to CSV

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

Convert manuscript to PDF for submission

curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key" \
  -H "Idempotency-Key: manuscript-v3-final" \
  -F "file=@manuscript_v3_final.docx" \
  -F "target=pdf" \
  --output manuscript_v3_final.pdf

Code example: automated data pipeline — XLSX to JSON

Research pipeline: instrument exports XLSX; pipeline needs JSON for ingestion into a database or API. No SDK — plain requests.

import requests
import json
from pathlib import Path

CTF_API_KEY = "ctf_sk_your_key_here"

def xlsx_to_json(xlsx_path: Path) -> list[dict]:
    """
    Convert an XLSX data export to a list of row dicts.
    Useful for loading instrument data into analysis pipelines.
    """
    with open(xlsx_path, "rb") as f:
        resp = requests.post(
            "https://changethisfile.com/v1/convert",
            headers={"Authorization": f"Bearer {CTF_API_KEY}"},
            files={"file": (xlsx_path.name, f)},  # source auto-detected
            data={"target": "json"},
            timeout=30,
        )
    resp.raise_for_status()
    return json.loads(resp.text)

def csv_to_json(csv_path: Path) -> list[dict]:
    """Convert CSV to JSON row dicts."""
    with open(csv_path, "rb") as f:
        resp = requests.post(
            "https://changethisfile.com/v1/convert",
            headers={"Authorization": f"Bearer {CTF_API_KEY}"},
            files={"file": (csv_path.name, f)},  # source auto-detected
            data={"target": "json"},
            timeout=30,
        )
    resp.raise_for_status()
    return json.loads(resp.text)

# Load instrument data
data = xlsx_to_json(Path("./data/experiment_run_04.xlsx"))
print(f"Loaded {len(data)} rows from instrument export")

JavaScript (fetch, no SDK):

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

  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 JSON.parse(await resp.text());
}

curl for pipeline use:

curl -sX POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer $CTF_API_KEY" \
  -F "file=@experiment_results.csv" \
  -F "target=json" \
  | python3 -m json.tool | head -20

Pricing for research team scale

A lab running weekly instrument exports (say 20 XLSX files → CSV/JSON) plus monthly manuscript and presentation conversions is roughly 100-300 conversions per month — free tier is sufficient. Labs with automated daily pipeline runs should use Hobby or Startup.

FAQ

Does JSON → CSV flatten nested JSON structures?

The conversion handles one level of nesting — a flat array of objects converts to a standard CSV with column headers. Deeply nested JSON (nested objects within objects) may produce unexpected column structures. Pre-flatten deeply nested data before converting if precise column control matters.

Can I convert YAML configuration files to JSON for analysis?

Yes — YAML → JSON and JSON → YAML are both supported, client-side in the browser. This is useful for comparing analysis configuration files or importing YAML-format instrument configuration into JSON-based pipelines.

Does the API handle scientific notation and precision in CSV/JSON conversions?

The conversion uses standard CSV/JSON parsing libraries. Floating-point values in scientific notation (e.g., 1.23e-4) are preserved as strings in CSV and as numbers in JSON if the value parses as a valid number. For analysis requiring high-precision floating-point values, verify the output format matches your analysis library's expectations before deploying.

What about RAW image formats from research cameras?

Common RAW formats (CR2, NEF, ARW, DNG) are not currently supported — these require specialized RAW processing software (dcraw, LibRaw) with debayering and color science that's outside standard conversion tooling. Use your camera manufacturer's software or a tool like darktable to convert RAW to TIFF or JPG before uploading.

Can I use this for automated figure generation in a build pipeline?

If your figures are generated as TIFF or high-res PNG and need JPG or WebP for web publication, yes — the API fits that pattern. For automated manuscript builds (e.g., R Markdown or LaTeX-generated DOCX → PDF), test conversion quality with your specific document structure before relying on it for submission.

Related guides

Conversion guides for research data and document workflows: