Batch Processing Multiple JSON Files in Desktop Formatters

If you need to format or validate dozens of JSON files, a normal desktop formatter is usually the wrong tool for the job. The practical desktop workflow is to keep a formatter for spot checks, then use a batch-friendly tool like jq, PowerShell, or Python to process an entire folder safely and consistently.

When Batch Processing Helps

Batch processing multiple JSON files is useful when you need to:

Why GUI Desktop Formatters Hit a Limit

A desktop JSON formatter is still useful when you want to inspect one broken file, compare structure, or make a quick edit. It becomes inefficient once the work is repetitive. Most GUI formatters do not offer reliable folder-wide processing, error logging, or safe overwrite behavior, so batch work usually shifts to command line tools or a short script.

Best Option for Most Desktops: jq

For most people, jq is the simplest answer. Current official jq documentation shows that it is available for Windows, macOS, and Linux, pretty-prints JSON by default with ., supports --indent for spacing, --sort-keys for stable object ordering, and --stream when individual files are too large to load normally.

Format into a New Folder First

Writing to a separate output directory is safer than overwriting files in place. It gives you an easy diff, lets you spot failures, and reduces the chance of damaging a whole dataset with one bad command.

mkdir -p formatted

for file in my_json_files/*.json; do
  base=$(basename "$file")
  echo "Formatting $base"
  jq --indent 2 --sort-keys '.' "$file" > "formatted/$base" || {
    echo "Failed: $file" >&2
  }
done

That command validates each file as it formats it. Files that fail to parse are skipped, and --sort-keys gives you cleaner diffs when object key order is inconsistent.

Overwrite in Place Only After Testing

If you really want to rewrite the originals, write to a temporary file first and replace the original only after jq succeeds.

for file in my_json_files/*.json; do
  tmp="$file.tmp"
  jq --indent 2 '.' "$file" > "$tmp" && mv "$tmp" "$file"
done

If you use a native jq.exe from WSL, MSYS2, or Cygwin, the current jq manual also notes that --binary can prevent unwanted newline conversion on Windows.

Native Windows Batch Formatting with PowerShell

If you want a Windows-native approach, PowerShell can parse and re-emit JSON without installing jq. The main gotcha is depth: current Microsoft documentation says ConvertTo-Json defaults to -Depth 2, which is too shallow for many real files, so set a higher depth explicitly.

$inputDir = ".\my_json_files"
$outputDir = ".\formatted"

New-Item -ItemType Directory -Force -Path $outputDir | Out-Null

Get-ChildItem $inputDir -Filter *.json | ForEach-Object {
  Write-Host "Formatting $($_.Name)"

  try {
    $json = Get-Content -Raw $_.FullName | ConvertFrom-Json
    $outFile = Join-Path $outputDir $_.Name

    $json |
      ConvertTo-Json -Depth 100 |
      Set-Content -Path $outFile -Encoding utf8
  }
  catch {
    Write-Warning "Skipping $($_.FullName): $($_.Exception.Message)"
  }
}

This is a good fit for normal configuration files and API payloads. If your JSON uses edge cases such as keys that differ only by letter case, current PowerShell documentation notes that ConvertFrom-Json with -AsHashtable can help, but jq is usually the safer formatter when you want exact, predictable batch output.

Python for Custom Batch Rules

Python is the best fallback when formatting is only one step in a larger cleanup job. You can normalize values, rename keys, split files into subfolders, or keep a detailed error log without adding much code.

from pathlib import Path
import json

input_dir = Path("my_json_files")
output_dir = Path("formatted")
output_dir.mkdir(exist_ok=True)

for path in input_dir.glob("*.json"):
    print(f"Formatting {path.name}")

    try:
        data = json.loads(path.read_text(encoding="utf-8"))
    except json.JSONDecodeError as exc:
        print(f"Skipping {path.name}: {exc}")
        continue

    output_path = output_dir / path.name
    output_path.write_text(
        json.dumps(data, indent=2, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )

This keeps the job simple: load each file, validate it by parsing, then write clean JSON back out. Add sort_keys=True if stable key ordering matters more than preserving original order.

Validation and Troubleshooting

• Validate without rewriting: run jq -e '.' file.json > /dev/null or use Get-Content -Raw file.json | ConvertFrom-Json > $null in PowerShell.
• Test a small sample first: a folder of 500 files can turn one bad assumption into 500 bad rewrites.
• Keep input and output separate at first: it makes review and rollback much easier.
• Watch out for JSON Lines: .jsonl or newline-delimited JSON is not the same as one JSON document per file, so use a line-oriented workflow instead of normal pretty-print commands.
• Use streaming for huge files: jq's current manual recommends --stream when a single file is too large for normal in-memory processing.
• Stay consistent on encoding: write UTF-8 output unless you have a specific downstream requirement.

Batch processing multiple JSON files on a desktop is less about finding a magical formatter button and more about choosing the right batch tool. For most teams, that means jq first, PowerShell on Windows when you want a native option, and Python when the workflow needs custom logic beyond formatting.