JSON to CSV

When Your Photo Metadata Lives in JSON and Your Client Wants a Spreadsheet

Every photographer who has ever worked with a modern DAM system, an API-driven stock library, or an AI tagging pipeline has faced the same moment of dread: you have thousands of image records neatly structured in JSON, and someone on the business side needs that data in Excel by end of day. JSON to CSV converters exist precisely for this gap — but the tool's actual value depends entirely on how well it handles the specific shape of photo and image metadata, which is rarely as flat and clean as tutorial examples suggest.

This is a case study of what happens when you push that kind of tool through a real workflow — not synthetic data, but the messy, nested, inconsistently keyed JSON that actual image management systems produce.

The Problem with Image Metadata JSON

Consider what comes back from a typical Getty Images API response, or an export from Adobe Lightroom's catalog via a custom plugin, or even the EXIF extraction output from ExifTool when you run it with -json flag across a folder of RAW files. The structure is never simple key-value pairs. You get nested objects ("location": { "city": "Mumbai", "country": "India" }), arrays of keyword tags ("keywords": ["portrait", "natural light", "outdoor"]), and arrays of objects for things like licensing terms or contributor credits.

Most naive JSON-to-CSV converters either silently drop nested keys or throw an error the moment they encounter an array. The JSON to CSV tool handles this through a flattening approach that deserves some explanation, because the choices it makes have real consequences for downstream use.

How the Flattening Actually Works — With a Real Image Example

Take this abbreviated JSON record from an Unsplash API response:

{
  "id": "abc123",
  "description": "Woman reading near window",
  "width": 4000,
  "height": 6000,
  "urls": {
    "raw": "https://images.unsplash.com/photo-abc123",
    "thumb": "https://images.unsplash.com/photo-abc123?w=200"
  },
  "tags": [
    { "type": "landing_page", "title": "reading" },
    { "type": "search", "title": "woman" }
  ],
  "user": {
    "name": "Priya Sharma",
    "portfolio_url": "https://psh.photography"
  }
}

When you paste this — or a thousand records in an array of this shape — into the JSON to CSV tool, it column-maps nested objects using dot-notation keys: urls.raw, urls.thumb, user.name, user.portfolio_url. These become clean column headers in the output CSV. For a photo agency analyst building a report on contributor output or image dimensions, these are exactly the columns they need without any post-processing.

The array case — those tags — is where the tool makes a specific decision that matters. It serializes each array as a JSON string within its cell rather than attempting to expand rows. So the tags column in your CSV will contain [{"type":"landing_page","title":"reading"},{"type":"search","title":"woman"}] as a single string. For most reporting purposes, this is the right call — exploding arrays into multiple rows would break the one-row-per-image assumption that makes the spreadsheet useful. If you need the tags separated, you can do that in Excel with a text-to-columns step or a quick Python split after the fact.

A Workflow That Actually Used This Tool

A small commercial photography studio in Bangalore was managing client deliverables through a custom Node.js system that logged every exported image as a JSON event — timestamp, file path, camera settings pulled from EXIF, the client project ID, and an array of approved usage rights. Monthly, the studio owner needed to send clients a usage report: which images from their project had been delivered, what rights applied, and the technical specs.

The previous workflow involved a junior staff member manually copying data from the JSON logs into a Google Sheet — about three hours of work per month across six to eight active clients. The JSON to CSV tool collapsed this to under twenty minutes:

1. Export the month's JSON log for a given client project (already a clean array of image objects from their Node.js system)
2. Paste into the JSON to CSV tool's input panel
3. Preview the column mapping — the tool shows you a table preview before you commit, which matters when you want to confirm that exif.focalLength and exif.iso came through correctly
4. Download the CSV and import directly into Google Sheets
5. Apply a saved Sheets template (logo, column formatting) — two minutes of work

The saved time was real. But more importantly, the accuracy improved — manual transcription had introduced errors in ISO values and focal lengths that occasionally caused confusion with clients about whether a specific shot was handheld or tripod-assisted.

Where It Handles Edge Cases Better Than Expected

Two specific behaviors stand out as genuinely useful for image data work.

Unicode in alt-text and descriptions. Image metadata frequently contains accented characters, non-Latin scripts (especially when dealing with stock libraries that serve multiple markets), and emoji in description fields. The tool outputs UTF-8 encoded CSV, which means opening it in Excel requires using the "From Text/CSV" import flow with explicit UTF-8 selection — not just double-clicking the file. This is a known Excel quirk, not a tool flaw, but it's worth knowing upfront so you don't open a CSV of image descriptions from a Japanese photography library and see garbage characters.

Inconsistent key presence across records. Real image metadata arrays are almost never uniform. One image might have GPS coordinates and another won't. ExifTool output is especially variable — a JPEG shot on a phone has different EXIF keys than a Canon RAW from a professional body. The JSON to CSV tool surveys all records in the array and builds a superset of all keys as column headers, then fills absent values with empty cells. This means your CSV has a complete column structure even if only thirty percent of images have a particular field populated. For photo archivists building comprehensive catalogs, this is the correct behavior.

Practical Limits Worth Knowing

• Very large exports — say, ten thousand image records with extensive nested metadata — can be slow in-browser. For bulk catalog work at that scale, the JSON to CSV tool is better used on chunked exports (per-project or per-date-range batches) rather than a single massive JSON dump.
• Arrays of primitive values (like a flat list of tags: "tags": ["wedding", "candid", "outdoor"]) serialize as a bracketed string in the cell. If you need these split into separate columns (tag_1, tag_2, tag_3), the tool doesn't do that automatically — you'd use Excel's TEXTSPLIT function or a quick script post-export.
• Deeply nested structures beyond two or three levels (which occasionally appear in IPTC metadata schemas) produce very long column header strings. They're accurate, just visually unwieldy until you rename them in your spreadsheet.

The Thing Most People Miss

The preview table is genuinely the most useful feature for image metadata work, and most people treat it as a formality before downloading. Spend thirty seconds actually reading the column headers in the preview. For EXIF-heavy exports, you'll often discover columns you didn't know were in your JSON — things like MakerNotes.FocusMode or Composite.LightValue that ExifTool extracts — that are actually useful for photo analysis work (figuring out what percentage of your shots used continuous autofocus, for instance, or correlating exposure value with keeper rate).

The preview also catches structural issues before you download. If you see a column called 0 or 1, it means your input was a JSON object with numeric keys rather than a proper array — which sometimes happens when APIs serialize arrays with explicit indices. Catching that in preview is faster than diagnosing it after importing a broken CSV into a client report.

Bottom Line for Visual Media Workflows

JSON to CSV earns its place in any photography studio, stock library, or visual content operation that touches APIs or modern metadata systems. It's not a replacement for a proper ETL pipeline when you're processing hundreds of thousands of records, but for the human-scale data tasks that come up constantly — client reports, catalog audits, metadata QA passes, deliverable logs — it removes friction from a step that otherwise pulls technical staff away from actual image work. The flattening logic handles real-world image metadata better than most browser-based tools, and the UTF-8 output means your multilingual descriptions survive the conversion intact.