DEV Community: daydayupc

How to Format JSON: Pretty-Print Like a Pro (2026 Guide)

daydayupc — Mon, 24 Aug 2026 13:06:07 +0000

How to Format JSON: Pretty-Print Like a Pro (2026 Guide)

Formatting JSON means three different things depending on the situation: making it readable with indentation, validating that it's actually valid, and shrinking it for production. The one-liner that covers the first two on any machine: python3 -m json.tool file.json. It pretty-prints and validates in one pass, it's in the Python standard library, and it's been there since Python 2.6. I use it daily for API responses and config dumps, and it has never let me down.

If you're in the browser instead, a JSON formatter tool does the same thing plus syntax highlighting — which becomes worth it the moment you're staring at a 2,000-line API response.

Why JSON ends up unreadable in the first place

Every API returns minified JSON. Every config file your tools emit is a single line. That's fine for machines — whitespace is meaningless to a parser — but it's brutal for humans. A 500 KB response with no indentation is unreadable; the same data with 2-space indents is a document you can actually navigate.

Minified JSON also hides problems. A missing comma or a stray quote sits invisibly in a wall of text, but the moment you pretty-print, the parser has to understand the whole structure — and it will tell you exactly where it broke.

The built-in ways to format JSON

You probably already have tools on your machine. No installs needed:

Python (any machine with Python 3):

python3 -m json.tool data.json            # pretty-print to stdout
python3 -m json.tool data.json --compact  # minify instead

Node.js (one-liner):

node -e "const d=require('fs').readFileSync(0,'utf8');console.log(JSON.stringify(JSON.parse(d),null,2))"

jq (the standard JSON Swiss Army knife):

jq . data.json        # pretty-print
jq -c . data.json     # compact (minified)

All three validate while they format. If the input has a syntax error, you get a parse error with a line number instead of garbage output — which is the real value of "just formatting" something.

What a good formatter does beyond indentation

Indentation is the baseline. The tools worth keeping do three more things:

Syntax validation with clear errors. A good formatter parses the input properly (not regex-hacks it) and tells you where the error is. "Expected ',' or '}' after property value at line 42" beats "invalid JSON" every time.

Minify mode. Same data, zero whitespace. This is what you ship to production — a payload that's often 20-40% smaller before you even enable gzip.

Syntax highlighting. Color-coded keys, strings, numbers and booleans make a 2,000-line response skimmable. It sounds cosmetic until you've debugged a nested config with it.

Two options worth mentioning: key sorting (alphabetical keys make diffs and comparisons much easier) and indent size choice (2 spaces is the community default; 4 or tabs if your team's style guide says so). Neither changes the data — both change how fast you can read it.

The workflow I actually use

Paste the minified JSON or drop the file.
If there's an error, read the line number it points at, fix the source, re-paste.
Beautify at 2-space indent, turn on highlighting, scan the structure.
When done, switch to minify and copy the compact version for the request body.

For the browser-based version, my tool ArkToolz JSON formatter covers all of it: beautify and minify modes, 2/4/tab indent, recursive key sorting, syntax highlighting, and exact error messages with positions. It all runs locally in your browser — paste a 10 MB config and nothing leaves your machine.

The JSON syntax rules people keep breaking

JSON is strict by design (RFC 8259). The rules that bite people daily:

No trailing commas. {"a": 1,} is invalid. JavaScript objects allow it; JSON doesn't.
No single quotes. {'a': 1} is invalid. Only double quotes around keys and strings.
No comments. JSON has no comment syntax. If you're using // in a config file, that's not JSON — it's a superset (like JSON5 or a JS object literal), and strict parsers will reject it.
No undefined or functions. JSON only supports objects, arrays, strings, numbers, booleans and null.

Most "invalid JSON" errors in practice come from one of those four. Know them and you'll spot the problem before the formatter does.

Frequently asked questions

Does formatting JSON change the data?
No. Pretty-printing only adds whitespace; minifying only removes it. The parsed structure is identical — which is exactly why validation happens at parse time, not format time.

What's the difference between JSON and a JavaScript object?
JSON is a text format with strict syntax rules; a JS object is an in-memory structure with more permissive syntax. {a: 1} is a valid JS object literal but invalid JSON. The strictness is the point — JSON is designed to be parsed by any language, not just JavaScript.

Why is my API response still huge after minifying?
Minifying removes whitespace only (typically 20-40%). The real size reduction comes from gzip/brotli at the transport layer and from trimming redundant fields at the source.

How do I format JSON in the browser console?
console.log(JSON.stringify(data, null, 2)) pretty-prints any JS object or parsed response. Most devtools also have a built-in "Response" tab that pretty-prints JSON automatically — check there before copying anything.

The 30-second checklist

[ ] Valid JSON (no trailing commas, single quotes, or comments)
[ ] 2-space indent for reading, minified for shipping
[ ] Syntax highlighting on for large responses
[ ] Key sorting on if you're diffing or comparing

Minified JSON is for machines; formatted JSON is for you. Validate with a proper parser, pretty-print at 2 spaces, and ship the minified version. A free online JSON formatter does all of it in your browser — no install, no upload, exact error messages included.

How to Merge PDF Files Free & Privately (2026 Guide)

daydayupc — Mon, 24 Aug 2026 09:23:10 +0000

How to Merge PDF Files Free & Privately (2026 Guide)

The fastest way to merge PDFs in 2026 is a browser-based tool that processes files locally — no account, no upload, no 20 MB email limit. Drag your PDFs in, check the order, hit merge. A 10-page contract plus a 3-page signature page becomes one file in about five seconds. I've merged invoices, contracts and product spec sheets this way for years, and I've never had a reason to go back to desktop software.

Before you merge anything, three things matter: the order of the files, the total size of the result, and whether any of your PDFs are locked. Everything else is just clicking.

Why you end up with multiple PDFs in the first place

It happens constantly. Your accountant sends a receipt as one PDF, your bank statement is another, and the signed version of the contract is a third. Email inboxes and download folders are full of single-page PDFs that were never meant to stay separate. Merging them isn't just tidier — it's practical: one file to send, one file to archive, one file to print.

What to check before you merge

Order. The result reads top to bottom in the order you drop the files. Most tools let you reorder before merging — use it. Renaming files to force alphabetical order is a workaround, not a workflow.

Size. Merging doesn't compress. If you combine three 15 MB scanned PDFs, you get one ~45 MB file. If the result is going into an email or a marketplace upload, check the final size and compress the PDFs first if needed.

Locked files. Some PDFs have restrictions set by the author. Good merging tools attempt the merge anyway and only warn you when a file genuinely can't be read. If one of your files is password-protected, you'll need the password before anything will work.

The main ways to merge PDFs, compared

Method	Cost	Privacy	Best for
Browser-based tool (local processing)	Free	Files never leave your device	Everyday merging, sensitive documents
Adobe Acrobat	Paid subscription	Uploads to Adobe servers	Heavy PDF workflows
macOS Preview	Free (built-in)	Local	Occasional merges on a Mac
Command line (pdfunite, PDFtk)	Free	Local	Batch/automated merging
Cloud upload tools	Free tier	Files uploaded to servers	When you don't care about privacy

The privacy row is the one that decides it for most people. Contracts, invoices, tax documents — none of that should sit on a random server "for 24 hours" while some startup decides what to do with it. Browser-based tools that run entirely in JavaScript don't have this problem: the PDF never leaves your machine, and there's nothing to delete later because nothing was ever stored.

The exact workflow I use

Drop the PDFs into the tool in the order I want them to appear.
Check the page counts shown next to each file — it catches wrong files fast.
Reorder with the up/down buttons if the drop order was wrong.
Merge and download the single result.

For the occasional terminal merge, pdfunite from poppler-utils does the same thing in one line:

pdfunite contract.pdf signature.pdf final.pdf

That's the whole command. It works on Linux and macOS, and on Windows via WSL.

If you'd rather stay in the browser, my tool ArkToolz PDF merge follows the exact workflow above: batch upload, per-file page counts, drag-free ordering with up/down buttons, and the merge happens locally in your browser — the files never touch a server. No signup, no size limit beyond what your browser can handle, and it's free.

Four mistakes I see people make

Merging in the wrong order. The bank statement ends up before the cover letter. Check the order before you click merge, not after.
Merging without checking size. Three large scans become one file that bounces off every email limit. Compress first when the result matters.
Using a cloud uploader for sensitive files. Tax returns and signed contracts don't belong on a random server, even temporarily.
Re-merging merged files. If you merge A+B, then merge that result with C, you're re-encoding pages and risking quality drift. Always merge from the originals.

Frequently asked questions

Does merging PDFs reduce quality?
No. A proper merge tool copies the pages as-is — it doesn't re-encode or compress them. The result is byte-identical in quality to the originals. (This is also why merging doesn't shrink file size.)

Can I merge password-protected PDFs?
Only if you have the password. Without it, the file can't be read, and no legitimate tool will bypass that. Some tools can merge PDFs with certain permission restrictions, but encryption always needs the password.

Is it safe to merge PDFs online?
It depends on the tool. If the tool processes files in your browser without uploading them, yes — that's the safest option available. If the tool asks you to upload files to a server, you're trusting that server with your documents.

What's the largest PDF I can merge?
With browser-based tools, the limit is your browser's memory rather than an artificial cap. If the merged file is huge, split the job into smaller batches.

The 30-second checklist

[ ] PDFs in the right order
[ ] No password-protected files (or password ready)
[ ] Final size fits your destination (email, upload, print)
[ ] Sensitive files merged in a local/browser tool, not a cloud uploader

Merging PDFs is a two-minute job when you have the right tool and the wrong one is a whole afternoon. Order first, check the size, keep it local. A free online PDF merger does all of it in your browser — no upload, no signup, no servers involved.

How to Compress Product Images for Ecommerce (2026 Guide)

daydayupc — Mon, 24 Aug 2026 08:47:37 +0000

How to Compress Product Images for Ecommerce (2026 Guide)

Here's the version I'd give any seller who asks: resize product photos to 1600-2048 px on the longest side, export as JPEG (or WebP if your platform serves it), and set quality to 75-80. That turns a typical 5 MB camera export into a 150-300 KB file with zero visible difference, even at full zoom. Your store gets faster, your Core Web Vitals stop crying, and no platform rejects your uploads.

I've helped set up stores on Shopify, Amazon and Etsy, and the same three knobs — size, format, quality — solve almost every image problem sellers hit. The platform limits below just tell you where the ceiling is; the compression settings tell you where to actually aim.

Why your product photos are 5 MB in the first place

Phone cameras and entry-level DSLRs default to huge resolutions. A 48-megapixel phone photo lands at 5-8 MB straight out of the camera. But here's the thing: the largest any storefront will ever display that image is about 2048 px wide, and most thumbnails are under 600 px.

That gap between what the sensor captured and what the page renders is where almost all the wasted bytes live. Close it once and you're done — no need to obsess over every slider afterward.

The cost of skipping this is real. Google's own research found that 53% of mobile visits are abandoned when a page takes longer than 3 seconds to load, and Amazon published a study estimating that every 100 ms of added latency costs them 1% of sales. Slow product images are a direct tax on your conversion rate.

Platform image limits, checked against seller rules

Every marketplace has its own upload limits. Here's what the current seller rules actually say (verified against platform documentation in 2026):

Platform	Recommended size	Upload limit	Notes
Shopify	2048×2048 px (square)	4472×4472 px or 20 MP, max 20 MB	Zoom needs ≥800×800 px
Amazon	≥1000 px longest side	Max 10000 px longest side	Main image must be pure white (RGB 255,255,255)
Etsy	2400×2400 px	Min 635×635 px	1:1 ratio, JPEG preferred
eBay	1600×1600 px	Min 500×500 px, <12 MB	JPEG preferred, zoom works at 1600 px
AliExpress	1000×1000 px	<5 MB per image	800×800 px minimum
Shopee	1000×1000 px	<2 MB	800×800 px minimum

Two patterns jump out. First, every platform's minimum is small (500-1000 px), but zoom features only kick in at 1000-2048 px — so shipping 1600-2048 px covers everyone. Second, the upload limits are all in megabytes, but the limits that actually matter for page speed are in kilobytes.

The three-knob method: size, format, quality

I compress product photos in this exact order, every time.

1. Resize to the display size, not the camera size. Set the longest side to 1600-2048 px for main product images, and 800-1000 px for lifestyle shots that only appear inline. A 4000 px photo displayed at 1200 px is roughly 80% wasted data.

2. Pick the format before touching quality. JPEG for anything photographic — it's what Shopify, Amazon and Etsy all recommend. WebP is 25-35% smaller than JPEG at the same quality and Shopify serves it automatically on supporting browsers, but many marketplaces still want a JPEG upload, so compress to JPEG and let the platform handle delivery. PNG is only worth it for images with transparency.

3. Set quality to 75-80, never 100. Quality 100 on a JPEG is mostly wasted bytes preserving artifacts nobody can see. Between 75 and 80, the difference from the original is invisible in normal viewing. I've A/B tested this with store owners who insisted they could spot compression artifacts at 400% zoom — at 100% zoom on a product page, none of them could.

A concrete example

A typical seller workflow: a 6 MB photo from a phone, destined for a Shopify product page at 2048×2048.

Resize to 2048 px longest side — drops to about 1.8 MB.
Convert to JPEG, quality 78 — drops to about 250 KB.
Upload. Done. The page loads three times faster, the zoom feature still works, and nobody can tell the file used to be 6 MB.

If you want to do all three steps in one go without installing anything, my tool ArkToolz image compressor handles resize + format + quality together in the browser. Files never leave your device, and batch mode processes a whole product catalog folder at once — which is exactly what you want when you have 200 SKUs and one deadline.

Five mistakes I see sellers make

Uploading the original camera file. The platform will accept it, then serve it slowly to every visitor. Compress before uploading, always.
Compressing an already-compressed file. Every lossy pass adds artifacts. Always compress from the original export.
Chasing quality 100. You can't see the difference on a product page, but your visitors can feel the load time.
Ignoring EXIF data. GPS coordinates and camera metadata hide kilobytes inside every photo. Most compressors strip it automatically — make sure yours does.
Using one giant image for thumbnails. Your 2048 px main image gets scaled down by the theme for the collection grid, but the browser still downloads the full file. If your platform doesn't auto-generate thumbnails, export a separate 400-600 px version for grids.

Frequently asked questions

What's the best image size for Shopify products?
2048×2048 px — it's what Shopify recommends, it enables the zoom feature, and it's large enough for any future use. Don't go near the 4472×4472 px ceiling; you're just shipping extra bytes.

Does Amazon really require a white background?
For the main image, yes. Amazon's rule is a pure white background (RGB 255,255,255) with no text, logos or watermarks on the product. Secondary images can be lifestyle shots.

JPEG or PNG for product photos?
JPEG, almost always. It's the format every marketplace recommends and it gives you the 60-90% size reduction you need. PNG is only for transparent-background images, which most marketplaces don't even allow for main images.

Can I compress images without losing quality?
Yes, if you compress from the original and stay at quality 75-80. Lossless formats like PNG keep every pixel but only save 10-40%; a well-tuned JPEG saves 60-90% with no visible loss.

The two-minute checklist

[ ] Longest side 1600-2048 px (800-1000 px for inline shots)
[ ] JPEG quality 75-80, or WebP if your platform serves it
[ ] EXIF stripped
[ ] Final file under 300 KB per image
[ ] Separate small version for grids if your platform needs it

Compress from the original, stay in the 75-80 band, and your store gets faster without anyone noticing the difference. A free online image compressor applies the whole checklist in your browser — no uploads, no signup, batch mode included.

Compressing Images Without Losing Quality: What Actually Works in 2026

daydayupc — Sat, 22 Aug 2026 17:43:38 +0000

Compressing Images Without Losing Quality: What Actually Works in 2026

The short version: set quality to 75-80, resize the image to the width it's actually displayed at, and use WebP or AVIF when the destination allows it. That gets most photos from multi-megabyte files down to 100-300 KB with zero visible difference.

I've shipped images this way on production sites for years, and I've A/B tested the settings below with designers who swear they can tell "quality loss" apart at 400% zoom. The numbers hold up. Here's the whole field guide.

Why your 4 MB photo is 4 MB in the first place

Modern phone cameras default to 48-megapixel photos. One shot from an iPhone 15/16 Pro or a Galaxy S-series lands at 5-8 MB before you do anything to it. Meanwhile the biggest any web page will ever display that image is usually 1200-2000 pixels wide.

So you're shipping 48 megapixels to show about 2. That gap — between what the sensor captured and what the screen can render — is where almost all the wasted bytes live. Shrink it once and you barely need to obsess over the rest.

Lossy vs lossless: there are only two buckets

Lossless keeps every pixel intact. File sizes drop 10-40%. PNG, GIF, and lossless WebP work this way. Right choice for logos, screenshots, and anything with text or sharp edges.
Lossy discards tiny color and detail variations your eyes rarely register. File sizes drop 60-90%. JPEG, lossy WebP, and AVIF work this way. Right choice for photos.

The trap people fall into: they think "quality 100" is the safe option. It isn't. A JPEG at quality 100 is mostly wasted data — the encoder is preserving artifacts you can't see. The real skill is finding the lowest quality number where you can't see a difference, not the highest one where you can. For photos that number is almost always 75-80.

Pick the format first, compress second

Choosing the format does half the work before you touch a single slider:

Format	Best for	Typical savings
JPEG	Photos, web, email	60-80% at quality 80
PNG	Logos, screenshots, transparency	10-40% (lossless)
WebP	Modern websites	25-35% smaller than JPEG at the same quality
AVIF	Modern browsers	roughly half of JPEG at the same quality
SVG	Icons, vector art	tiny, infinitely scalable

WebP is supported in every modern browser (caniuse lists it as green across the board), and AVIF covers everything except older Safari versions. The easiest win on the web: serve AVIF or WebP with a JPEG fallback and let the browser decide:

<picture>
  <source srcset="photo.avif" type="image/avif">
  <source srcset="photo.webp" type="image/webp">
  <img src="photo.jpg" alt="Your photo" width="1920" height="1080" loading="lazy">
</picture>

That snippet alone will cut your image payload by 50-70% on most browsers, and nobody who visits your site will ever know the difference.

The exact settings I use

These are the numbers I actually ship with, not the ones from a random blog post:

Quality: 75-80. Start at 80 for photos. Below 60, smooth gradients start to band and edges get crunchy.
Width: the display width. Resize to the largest size the image will ever be shown at. A 4000px photo displayed at 1200px is about 80% waste.
Format: WebP or AVIF when possible, JPEG otherwise. For screenshots and logos: PNG or lossless WebP — never lossy.

If you'd rather stay in the terminal, ImageMagick does all three in one line:

magick photo.jpg -quality 80 -resize 1920x1920\> photo.webp

Or in Python with Pillow:

from PIL import Image

img = Image.open("photo.jpg").convert("RGB")
img.thumbnail((1920, 1920))          # resize to display size
img.save("photo.webp", "WEBP", quality=80, method=6)  # method=6 = slowest, best compression

And if you want a browser-only option, my tool ArkToolz image compressor does the same thing in the browser — no upload, the file never leaves your device, batch mode handles a whole folder at once.

Four mistakes I see everywhere

Quality 100. Wasted bytes, no visible benefit. Start at 80 and step down until you notice.
Recompressing an already-compressed file. Each lossy pass adds artifacts. Always compress from the original.
Ignoring EXIF. GPS, camera model, timestamps — that's kilobytes of metadata hiding in every photo. Most decent compressors strip it automatically.
Deleting the original. Compression edits a copy, never the source. Storage is cheap; reshoots are not.

Frequently asked questions

Does compressing an image ruin the quality?
Only if you push lossy compression too far. Between 75-80, the difference is invisible to the human eye. Lossless compression doesn't touch quality at all.

What's the best format for photos in 2026?
WebP at quality 80 is the best size-to-quality balance in most browsers right now. AVIF is smaller still if your audience runs modern browsers. For screenshots and text-heavy images, PNG or lossless WebP.

Can a 5 MB photo really become 100 KB?
Often yes — but usually it takes two levers at once: quality around 75 plus resizing to display width. Either one alone might not get you there.

Go compress something

Format first, then quality 75-80, then display size. That's the whole playbook. A free online image compressor applies all three in one go, right in your browser — drop a file in and watch it come back 60-90% smaller while the quality stays put.

This article was originally published on the ArkToolz blog.