DEV Community: tavi

How to Use a Realistic Test Data Generator (Faker) in 5 Steps

tavi — Wed, 16 Sep 2026 12:30:45 +0000

Why fake data that looks fake causes real bugs

You've been there: you seed a dev database with user1@test.com, John Doe, and 123 Main St, then ship. QA signs off because the form accepts it. Two weeks later a real customer with a 47-character hyphenated surname and a + in their email hits a validation regex you never stress-tested. The fake data was too polite.

That's the gap a realistic test data generator built on faker.js closes. Instead of typing placeholders by hand, you describe the shape of your data once, and the generator produces thousands of rows that actually look like the messy real world — accents, long names, edge-case punctuation, plausible dates. This walkthrough uses Mock Data Generator, which runs faker.js entirely in your browser. Nothing is uploaded, nothing is sent to an external API, and there's no signup wall before you can generate a single row.

How to generate realistic test data in 5 steps

Step 1 — Build your schema

Open the Mock Data Generator and add one field per column you need. For each field, pick a type — name, email, address, date, and the rest of the available set. The free tier gives you 15 field types, which covers the usual suspects for a users table, an orders table, or a product catalog.

Name your fields exactly as your code expects them. If your API returns created_at and not createdAt, use created_at. Renaming columns after the fact is the single most common source of "why doesn't this import" headaches.

Step 2 — Decide how many rows you actually need

Set the row count. The free tier goes up to 20,000 rows, which is more than enough to expose pagination bugs, slow queries, and UI that breaks past page three. If you're testing a virtualized list or a bulk-import path, that ceiling is where you'll feel the limit.

A practical tip: generate a small batch first (50–100 rows), eyeball it, then scale up. Catching a wrong field type at 100 rows takes seconds; catching it at 20,000 means regenerating everything.

Step 3 — Generate

Hit generate. faker.js runs locally in your browser tab, so the whole thing is a client-side loop. That matters for two reasons. First, it's fast — no round trip per row. Second, and more importantly for anyone working under an NDA or with production-like schemas, your field names and structure never leave your machine. There's no server logging your schema, because there's no server involved.

Step 4 — Preview before you commit

Look at the preview table. Check the obvious things: are dates in a sane range, are emails well-formed, did any field come back empty when it shouldn't? This is also where you spot the subtle stuff — a "name" field that only ever produces single-token values won't test your two-column layout.

Step 5 — Export as JSON or CSV

Download the result as JSON or CSV. JSON slots straight into a seed script or a mock API response; CSV drops into a spreadsheet or a COPY command. Pick based on where the data is going, not on habit.

When you need more than the free tier

The free limits are honest ones: 20,000 rows and 15 field types. If your work regularly pushes past that, there's an optional one-time Pro upgrade at $14.99. It removes the row cap, opens up 30+ field types including locale data (useful when you're testing internationalization and need names and addresses that aren't all US-shaped), lets you save up to 20 schemas in IndexedDB so you're not rebuilding the same table every morning, and adds SQL INSERT and multi-format ZIP export. It's also ad-free.

If you only generate test data once a month, the free tier is genuinely enough. Don't upgrade out of habit.

The alternative: scripting faker.js yourself

Before reaching for any tool, it's worth knowing what the DIY version looks like. faker.js is an npm package, so you can install it and write a seed script:

npm install @faker-js/faker

import { faker } from '@faker-js/faker';

const users = Array.from({ length: 1000 }, () => ({
  id: faker.string.uuid(),
  name: faker.person.fullName(),
  email: faker.internet.email(),
  created_at: faker.date.past().toISOString(),
}));

console.log(JSON.stringify(users, null, 2));

Trade-offs, honestly: a script is reproducible and lives in your repo, which is great for CI. But it needs Node installed, a package.json, and a decision about whether to commit the generated output. Changing the schema means editing code, not clicking a field. And if a designer or PM wants 200 rows of sample data for a mockup, handing them a Node script is a worse experience than handing them a CSV.

The browser tool wins when the schema is still in flux, when a non-developer needs the data, or when you don't want test fixtures sitting in version control. The script wins when generation is part of an automated pipeline you run repeatedly.

Practical tips that save time later

Generate edge cases on purpose. Realistic data is good, but deliberately weird data is better. If the generator lets you vary field types, mix in long strings and unusual characters so your validation actually gets exercised.
Keep the schema, not just the output. Regenerating from a saved schema beats hand-editing a CSV when requirements shift.
Match your real column names and types. A date field that exports as a string will break a strict database import. Know what your target expects.
Don't paste real customer data into any generator. The whole point of fake data is that it isn't real. If you're handling sensitive files elsewhere, the same instinct applies — see how our privacy page describes the browser-only approach.
Check row counts against your actual test. 20,000 rows is plenty for most UI work but nothing for a load test. Know which one you're doing.

If you're also wrangling structured data around your test fixtures, the JSON to CSV converter handles the flattening side, and the Meta Generator is there when you need structured data for a page rather than a database.

FAQ

Is this a real faker.js implementation or just something that looks like it?

It runs faker.js locally in your browser tab. The same library you'd install via npm is doing the generation, just without the Node setup. That means the data shapes — names, emails, addresses, dates — follow faker's own rules rather than a hand-rolled random string generator.

Do I need to create an account to generate test data?

No. There's no signup step before you can build a schema and generate rows. You open the page, add fields, pick types, and generate. Accounts aren't part of the workflow at all.

What's the row limit on the free tier?

Free generation goes up to 20,000 rows with a set of 15 field types. If you routinely need more rows, locale-specific data, or saved schemas, there's an optional one-time Pro upgrade at $14.99 that lifts the row cap and adds 30+ field types, IndexedDB schema saving, and SQL INSERT plus multi-format ZIP export.

Can I export directly to a SQL INSERT statement?

SQL INSERT export is a Pro feature, alongside multi-format ZIP export. On the free tier you get JSON and CSV, which cover most seeding scripts and spreadsheet imports. If your workflow is database-first, that's the feature to weigh when deciding on Pro.

Is it safe to use with schemas that mirror production tables?

Yes, and that's a good reason to prefer it. Because faker.js runs client-side, your field names and structure aren't transmitted anywhere. There's no external API call carrying your schema. You still shouldn't paste real customer records in as a starting point — generate from a schema instead.

How does this compare to Mockaroo or similar SaaS generators?

The main practical differences are the signup requirement and where the data is processed. Browser-based generation means no account and no schema leaving your machine. SaaS generators often have richer collaboration and sharing features. If you're a solo developer or a small team generating fixtures locally, the browser route usually gets you there faster.

Stop Doing This Wrong: ExifTool Alternative Online Free

tavi — Tue, 15 Sep 2026 12:30:06 +0000

I keep seeing the same pattern in freelancer forums and group chats: someone strips metadata from a batch of photos, feels safe, then posts the same set on Instagram or sends a client a "cleaned" folder that still carries GPS coordinates in the original files. The tool wasn't the problem. The workflow was. Here are the mistakes that actually leak location and camera data, and how to fix each one.

Mistake 1: Assuming the browser tool uploaded your photo

This is the big one, and it cuts both ways. Some people avoid online EXIF tools entirely because they assume every web app ships files to a server. Others use one and assume the opposite without checking. Both guesses are risky.

The fix: look for a tool that states plainly that processing happens in the browser. EXIF Remover reads files locally with exifr and strips metadata by drawing the image to a Canvas and exporting a fresh blob. Nothing goes over the network. If you want the longer version of why that matters, the privacy page covers the site's stance.

A quick sanity check you can run yourself: open DevTools, switch to the Network tab, drop a photo into a browser-based tool, and watch. If you see a multi-megabyte POST request, the file left your machine. If you only see your own page assets, it didn't.

Mistake 2: Thinking a screenshot is the same as stripping metadata

I've watched people "remove EXIF" by taking a screenshot of a photo and saving that. It works in a narrow sense — screenshots usually don't carry camera EXIF — but it also destroys resolution, strips color profiles, and often changes the aspect ratio. For client deliverables, that's a downgrade disguised as a privacy fix.

The fix: re-encode the actual file instead of screenshotting it. In EXIF Remover, the flow is:

Drop a JPG, PNG, WebP, or HEIC file (HEIC only if your browser can decode it).
Review the grouped table — GPS coordinates, camera model, lens, timestamp, ISO, software.
Click Strip EXIF and download the cleaned image.

The output is re-encoded through Canvas at roughly JPEG quality 0.92. That's not bit-identical to the original, and nobody should claim it is. What it does give you is a clean image at full resolution with the metadata channels removed.

Mistake 3: Stripping the copy but shipping the original

This one is quiet. You clean a photo, download photo-clean.jpg, and then attach photo.jpg from your camera roll because it's the one already in your recent files. The cleaned version sits in Downloads and never gets sent.

The fix: rename on download, or move originals into a separate folder before you start. The tool never touches your original file on disk — that's a feature, not a bug — which means the original is still sitting there with GPS intact until you deal with it.

If you're handling a batch, this is where the free tier's 10-file limit per run becomes a real workflow constraint. The optional Pro license bumps that to 50 per run and adds a privacy risk report with a score, plus CSV/JSON export of the metadata. If you're auditing a folder of 200 photos, that report is the part that saves time.

Mistake 4: Trusting the social app to strip it for you

Instagram, Facebook, and most major platforms do strip EXIF on upload. That's true. What people miss is the gap between upload and the platforms that don't strip it: email attachments, Slack, Discord, Google Drive shares, WeTransfer, and your own website's CMS.

The fix: treat stripping as a step you own, not a step you outsource to whichever app you're posting in. If you want a checklist that covers the common leak points, the photo metadata privacy risks checklist on the blog walks through it.

Mistake 5: Believing "strip EXIF" means "strip everything"

No browser tool removes every possible metadata channel. Some formats embed data in ways that survive re-encoding. Some tools only handle a subset of fields. Honest tools say so.

The fix: know what you're getting. EXIF Remover strips EXIF, GPS, and camera metadata by re-encoding. It does not offer selective field removal — you can't keep the lens info and drop only GPS. It also doesn't claim forensic-grade wiping of every metadata channel. If your threat model requires that level of assurance, use ExifTool locally with -all= and verify with exiftool -a -G1 afterward. That's the honest trade-off: more control, more command-line work.

Mistake 6: Forgetting that "free" and "no premium" aren't the same thing

The keyword is "exiftool alternative online free," and that's accurate — the browser tool is free to use with an optional one-time Pro upgrade. People sometimes assume "free online tool" means there's no paid tier at all, then feel misled when they hit a limit.

The fix: read the limits before you start. Free covers up to 10 photos per run, which is plenty for a single client delivery or a few social posts. Pro is a one-time $12.99 and covers 50+ per run, the privacy risk report, CSV/JSON metadata export, and removal of Toolkite branding. If you're doing occasional personal use, free is genuinely enough. If you're running a photo workflow for clients, Pro pays for itself in one batch.

A power-user alternative worth knowing

If you live in a terminal, ExifTool itself is still the gold standard for control. A one-liner like:

exiftool -all= -overwrite_original *.jpg

strips metadata across a folder in place. The trade-offs are real: you need it installed, you need to be comfortable with the flags, and -overwrite_original is unforgiving if you point it at the wrong directory. For a quick one-off — a single photo you want to post right now — a browser tool is faster and has no install step. For scripted pipelines, ExifTool wins. Pick based on the job, not on loyalty.

What to actually do next

If you found this because you're cleaning up a batch before sending it out, start with the EXIF Remover and run your first photo through it. Check the grouped table before you strip — you'll probably be surprised what's in there. Camera model, lens, ISO, and often a timestamp accurate to the second. Then strip, download, and verify by re-dropping the cleaned file into the same tool. If the table comes back empty, you're done.

If you also watermark client photos before delivery, the watermark tool runs on the same browser-only model, so you can keep the whole prep pipeline local.

FAQ

Is a browser-based EXIF remover actually as private as ExifTool?

For the specific job of stripping EXIF, GPS, and camera metadata, a browser tool that processes locally gives you the same practical privacy outcome as ExifTool — the file never leaves your machine. The difference is control: ExifTool lets you script, batch, and target specific fields, while a browser tool trades that control for zero install and a visual review table. Neither is universally better; it depends on whether you need scriptability or convenience.

Does stripping EXIF reduce image quality?

Yes, slightly, because the image is re-encoded through Canvas rather than having metadata surgically removed from the original bytes. In EXIF Remover the JPEG export runs at roughly quality 0.92, which is visually lossless for most photos but not bit-identical. If you need pixel-perfect preservation of the original encoding, use ExifTool with -all= on the original file instead.

Can I remove only the GPS data and keep the camera info?

Not with EXIF Remover — it strips all metadata at once by re-encoding the image. There's no GPS-only or keep-lens mode. If selective removal matters to you, ExifTool supports field-level control with flags like -gps:all=. For most people sharing photos publicly, removing everything is the simpler and safer default.

Why does my photo still show a location after I stripped it?

The most common cause is that you sent the original file instead of the cleaned download. The tool never modifies your original on disk, so both versions exist side by side. Another cause is that the receiving platform re-added location from a different source, like a check-in tag. Re-drop the cleaned file into the tool and check the table — if it's empty, the file itself is clean.

How many photos can I process for free?

The free tier handles up to 10 photos per run, which covers most single-delivery and social-posting use cases. The optional one-time Pro license raises that to 50+ per run and adds a privacy risk report with a score, CSV/JSON metadata export, and removal of Toolkite branding. There's no subscription — it's a single purchase if you decide you need the batch capacity.

Does HEIC from an iPhone work in a browser EXIF remover?

It depends on your browser. EXIF Remover accepts HEIC files, but only if the browser itself can decode that format. Safari on macOS and iOS generally can; some Chrome and Firefox configurations cannot. If your HEIC file won't load, convert it to JPG first, then strip the metadata from the converted file.

JSON to Excel Converter Online: What Actually Works in 2026

tavi — Mon, 14 Sep 2026 12:30:20 +0000

You've got a JSON file that a developer handed you, or an API response you saved to disk, and someone upstairs wants it as a spreadsheet by Friday. The obvious move is to paste it into some random "convert" site and hope for the best. The less obvious move is to think for ten seconds about what you're actually pasting — because API responses are full of tokens, customer IDs, and internal field names you probably shouldn't be handing to a stranger's server.

This is a walkthrough of how to get from JSON to a real Excel file (.xlsx) without uploading anything, what breaks when your JSON is nested, and when you should skip the browser entirely and write a script.

What "JSON to Excel" actually means

People say "Excel" loosely. There are three different outputs hiding behind that word, and picking the wrong one is why your columns look like garbage:

CSV — plain text, comma-separated. Opens in Excel fine. No formatting, no multiple sheets, no data types.
XLSX — the real Excel format. Preserves types better, handles larger row counts, and won't mangle long numbers the way CSV sometimes does.
A flattened table — this is the one that matters. If your JSON has objects inside objects, neither CSV nor XLSX will magically know what to do with them. You have to flatten first.

If your JSON looks like this, you're in the easy case:

[
  { "id": 1, "name": "Ada", "plan": "pro" },
  { "id": 2, "name": "Grace", "plan": "free" }
]

An array of flat objects converts cleanly to columns id, name, plan. Done.

If it looks like this, you have decisions to make:

[
  {
    "id": 1,
    "customer": { "name": "Ada", "address": { "city": "London" } },
    "tags": ["vip", "renewal"]
  }
]

Now you need to decide whether customer.address.city becomes its own column, and what happens to the tags array. That's the flattening problem, and it's where most online converters quietly fall over.

Use our online tool: JSON ↔ CSV Converter

The JSON ↔ CSV Converter runs entirely in your browser — PapaParse and SheetJS doing the work locally, no file ever leaving your machine. That matters if the JSON contains anything you wouldn't post publicly.

Here's the actual flow:

Paste or upload. Drop a .json or .csv file, or paste the text directly. Free tier handles files up to about 25MB.
Pick your direction. JSON→CSV, CSV→JSON, or JSON→Excel (.xlsx).
Convert and download. Copy the result or download it immediately.

For nested JSON, the free tier flattens up to 10 levels deep, which covers the vast majority of API payloads I've seen. If you're dealing with something genuinely gnarly — deeply nested config dumps, multi-level event logs — the Pro tier goes deeper, raises the file ceiling to 50MB with a progress bar, and adds batch conversion up to 10 files at once. Pro is a one-time $9.99, not a subscription.

There's also a custom delimiter option and an API URL fetch if you'd rather point the tool at an endpoint than save the response first. That fetch is the one operation that touches the network, and it goes through a CORS proxy — worth knowing if the endpoint is internal.

When flattening goes wrong (and how to spot it)

Flattening is not lossless, and pretending otherwise causes real bugs. Three things to watch:

Arrays inside objects. A field like tags: ["vip", "renewal"] has to become something. Usually it gets joined into a single cell like vip, renewal. That's fine for reading, terrible for filtering later — Excel will treat the whole thing as one string.

Repeated keys across records. If record A has customer.address.city and record B doesn't, you'll get an empty cell. That's correct behavior, but it means your column list is the union of every key across every record. A single weird record can add twenty useless columns.

Type drift. Numbers stored as strings in JSON stay strings. Excel will happily left-align them and refuse to sum them until you convert. Check a numeric column after import — if the values are left-aligned, they're text.

A quick sanity check: count your source records, count your output rows, and confirm they match. If they don't, something got collapsed.

The alternative: a script you control

If you're converting the same shape of JSON every week, stop doing it by hand. A short Python script is more honest about what's happening:

import pandas as pd

df = pd.json_normalize(pd.read_json("input.json"))
df.to_excel("output.xlsx", index=False)

json_normalize handles the flattening, and you can control the separator (sep="_" instead of the default .) so your column names don't look like file paths.

The trade-offs are real, though. You need Python and pandas installed, you need to remember the command, and you need to actually be at a machine where that's set up. For a one-off conversion on a laptop you don't control, that's a lot of ceremony. The browser tool wins on convenience; the script wins on repeatability and on shapes that need custom logic.

If your data is sensitive and you don't want to install anything, browser-side conversion is the safer middle ground — nothing leaves the device, and you can verify that by watching your network tab. Same reasoning applies to other file-handling chores; it's why tools like the EXIF Remover exist for photos, and the same principle shows up in our privacy notes.

Practical tips before you hit convert

A few things that save time:

Validate the JSON first. A trailing comma or a stray comment will break the parse. Paste it into any JSON validator before converting.
Decide your column names early. customer.address.city is readable; customer_address_city is easier to work with in formulas. Pick one convention and stick to it.
Watch the row limit. Excel tops out around 1,048,576 rows. If you're near that, you probably want a database, not a spreadsheet.
Keep the original. Always retain the source JSON. Flattening is one-way, and you'll want to re-derive a different view later.
Check encoding on export. If your data has accented characters or emoji, open the output once and confirm nothing turned into ?.

If you're generating test data to convert in the first place, the mock data generator can produce JSON you can feed straight into the converter — useful for building a template before the real payload arrives.

The short version

For an array of flat objects, any converter works. For nested JSON, you need something that flattens predictably and tells you what it did. For anything with customer data in it, you want that conversion happening on your machine, not someone else's. The JSON ↔ CSV Converter covers the first two and is honest about the third — which is more than most of the sites ranking for this keyword can say.

FAQ

Does converting JSON to Excel in the browser actually produce a real .xlsx file?

Yes. The tool uses SheetJS locally in your browser to build a genuine .xlsx workbook, not a renamed CSV. You get a file Excel opens natively, with the data types it can infer from your JSON preserved as well as the format allows.

What happens to nested objects when I convert JSON to Excel?

They get flattened into columns, typically using a separator like a dot or underscore, so customer.address.city becomes its own column. The free tier handles nesting up to 10 levels deep, which covers most API responses. Arrays inside objects usually get joined into a single cell, so check those columns if you plan to filter on them.

Is there a file size limit for JSON to Excel conversion?

On the free tier, files up to roughly 25MB work fine. If you regularly deal with larger payloads, the Pro option raises that to 50MB and shows a progress indicator during conversion. Pro is a one-time $9.99 purchase rather than a recurring subscription.

Can I convert JSON from an API URL directly instead of saving it first?

Yes, that's one of the Pro features — you can point the tool at an API URL and fetch the response for conversion. Be aware this is the one operation that uses the network, routed through a CORS proxy, so avoid it for internal or authenticated endpoints you wouldn't want proxied.

Why do my numbers show up as text after converting to Excel?

Because JSON stores them as strings, and the converter preserves that. Excel left-aligns text and won't sum it. Select the column, use Text to Columns or multiply by 1 in a helper column, or fix the source JSON to emit real numbers before converting.

Should I use a browser converter or a Python script for this?

Use the browser tool for one-off conversions, files you don't want to upload, or machines where you can't install anything. Use a script when the same JSON shape arrives on a schedule, when you need custom flattening logic, or when the conversion is part of a larger pipeline.

Clean Image Metadata Before Client Delivery — Browser Tool vs ExifTool

tavi — Sun, 13 Sep 2026 12:32:37 +0000

You've got a folder of selects, the client approved the shots, and now you're about to send them out. Before that email leaves your outbox, think about what's riding along inside each JPEG: your camera body, your lens, the exact GPS coordinates of the shoot, and often your editing software and a timestamp. For a wedding photographer, that's a home address in a file that gets forwarded around. For a real estate shooter, it's a client's property pin. Cleaning that metadata before delivery isn't paranoia — it's basic client care.

The question is how you do it. Two paths dominate: a browser-based tool like EXIF Remover, or a command-line approach like ExifTool. Both remove metadata. They differ in where your files go, how much you can script, and how much control you get over individual fields.

Quick comparison

	Browser tool (EXIF Remover)	ExifTool (CLI)
Where files are processed	In your browser, on your device	On your machine
Upload required	No	No
Install needed	No	Yes
Selective field removal	No — strips all metadata	Yes — granular flags
Batch size	10 free, 50+ with Pro	Unlimited (your disk is the limit)
Metadata export	CSV/JSON with Pro	Yes, many formats
Formats	JPG, PNG, WebP, HEIC (if browser decodes)	Very broad
Learning curve	Low	Moderate to steep

That table is the honest version. The browser tool is faster to start and keeps files off any server. ExifTool gives you surgical control and scriptability, but you have to install it and learn its flags.

When the browser tool wins

If you're a freelancer delivering a handful of images per client, the browser route is almost always the right call. You drag files in, you see the metadata laid out in a grouped table — GPS coordinates, camera model, lens, timestamp, ISO, software — and you click Strip EXIF. Then you download the cleaned image.

A few things worth knowing about how this actually works:

The tool reads metadata with exifr running locally in your browser. Nothing is sent anywhere.
Stripping happens by drawing the image to a Canvas and exporting a fresh blob, so the output is a new file. Your original on disk is untouched.
Because it's a re-encode, JPEG output is recompressed at roughly quality 0.92. That's visually fine for client delivery, but don't expect a bit-identical file.
HEIC works only if your browser can decode it. If it can't, you'll need to convert first.

The workflow, step by step

Drop your photo onto the page — JPG, PNG, WebP, or HEIC — or click to browse. Nothing uploads.
Review the EXIF fields in the grouped table. This is your last chance to spot a GPS tag you didn't know was there.
Click Strip EXIF and download the clean image.

If you're delivering to a client who cares about privacy (or you just don't want your home studio coordinates floating around), that's the whole job. Ten photos per run on the free tier; Pro bumps it to 50+ per run and adds a privacy risk report with a score, CSV/JSON metadata export, and removes Toolkite branding. It's a one-time $12.99 if you want it — the free tier is genuinely usable without it.

One caveat: the tool strips all metadata. There's no GPS-only mode and no "keep the lens info" option. If you need that granularity, see the next section.

When to use alternatives

ExifTool is the right tool when you need precision. Say you want to keep the copyright tag but kill the GPS block, or you're processing 400 images from a corporate shoot and want it scripted into your delivery pipeline. A typical command looks like:

exiftool -all= -overwrite_original *.jpg

That wipes everything. For selective removal you'd use flags like -gps:all= to drop only GPS, or -XMP:all= for a specific block. The trade-off is you need to know which tags matter and test on copies first — it's easy to nuke something you wanted to keep.

Other alternatives worth mentioning honestly:

OS-level export options. Some photo apps strip metadata on export, but the behavior varies and isn't always obvious. Check before you trust it.
Desktop batch utilities. They work, but you're installing software and often clicking through more UI than the browser tool requires.
Online upload-based strippers. These exist, but you're handing your client's photos to someone else's server. For client work, that's usually a non-starter.

If you're also watermarking before delivery, that's a separate step — Watermark handles batch watermarking in the browser too, so you can strip metadata and brand images without either file leaving your machine.

Edge cases that trip people up

A few things I've run into that are worth flagging:

Screenshots and PNGs. These often carry less metadata than camera JPEGs, but they can still hold software tags. Strip them anyway if they're going to a client.
Re-encoding artifacts. If you're delivering a JPEG that's already been through several edits, another re-encode at 0.92 is usually invisible, but for print-critical work, keep a master copy.
HEIC from iPhones. These are the ones most likely to carry GPS. If your browser can't decode HEIC, convert to JPEG first, then strip.
Metadata isn't only EXIF. XMP and IPTC blocks can carry author names and edit history. The browser tool removes metadata by re-encoding, which handles the common channels — but if you need forensic-grade certainty across every possible channel, that's an ExifTool job, not a browser one.

A practical delivery checklist

Before you hit send on client files:

Strip metadata on every image in the batch.
Spot-check one file by re-opening it in the tool to confirm the GPS and camera fields are gone.
Watermark if your contract requires it.
Keep your originals — the stripped versions are new files, so your archive stays intact.

That's it. No uploads, no accounts, no server round-trip. If you want to see what's actually inside your photos before you decide, the tool shows you the full metadata table first — which is often the moment people realize how much their camera was recording.

FAQ

Does stripping metadata with a browser tool change the image quality?

Slightly, yes. The browser tool removes metadata by drawing the image to a Canvas and exporting a new blob, which re-encodes JPEG at roughly quality 0.92. For client delivery and social media that's visually indistinguishable, but it's not a bit-identical copy of the original. Always keep your master files.

Can I remove only the GPS data and keep the camera info?

Not with the browser tool — it strips all metadata in one pass, so there's no GPS-only mode. If you need selective removal, ExifTool supports granular flags like -gps:all= that target specific tag groups. The trade-off is a steeper learning curve and the need to test on copies first.

Is it safe to strip metadata from client photos in a browser?

Yes, because the processing happens locally on your device. The tool reads metadata with exifr in the browser and never uploads your files to a server. Your originals on disk stay unchanged, and the cleaned version downloads as a new file.

How many photos can I clean at once before delivery?

The free tier handles up to 10 photos per run. If you're delivering larger batches, the optional Pro license raises that to 50+ per run and adds a privacy risk report with a score, CSV/JSON metadata export, and removal of Toolkite branding. It's a one-time purchase, not a subscription.

What about HEIC files from an iPhone?

HEIC is supported only if your browser can decode it. If it can't, convert the HEIC to JPEG first and then strip the metadata. iPhone photos are among the most likely to carry GPS coordinates, so this step matters for client work.

Does the browser tool wipe every possible metadata channel?

No, and it doesn't claim to. Re-encoding through Canvas removes the common EXIF, GPS, and camera channels, but it isn't forensic-grade wiping of every possible metadata container. If you need certainty across XMP, IPTC, and obscure channels, use ExifTool and verify the output.

Why Is My Batch EXIF Removal Still Showing Location? (Fix Without Uploading)

tavi — Fri, 11 Sep 2026 12:37:35 +0000

You ran a batch strip, checked the file, and the GPS pin is still there. Or the photo opened fine on your laptop but Instagram still guessed your neighborhood. If that sounds familiar, the problem usually isn't the tool — it's which copy of the file you're inspecting, or which metadata channel survived the pass.

This is a troubleshooting walkthrough for anyone cleaning a folder of photos before sending them to a client, posting them, or handing off a drive. The goal is simple: batch remove EXIF without uploading anything to a server, and actually confirm it worked.

Why metadata survives a "successful" strip

There are three common culprits, and they look identical from the outside.

1. You're checking the original, not the export. Most browser tools — including EXIF Remover — leave your source file untouched on disk. The cleaned version is a new download. If you re-open the same file from your camera roll or Downloads folder, you're looking at the original. This is the single most common reason people think the strip failed.

2. The format didn't get re-encoded the way you assumed. EXIF removal by re-encoding (drawing the pixels to a canvas and exporting a fresh blob) works reliably for JPG, PNG, and WebP. HEIC is conditional — it only works if your browser can decode HEIC in the first place. On browsers that can't, the file may not process at all, or may fail silently in a batch. That's not a bug in the strip logic; it's a decode limitation.

3. Something downstream re-added metadata. Some editors, cloud sync clients, and social upload flows write their own metadata fields. If you strip, then open the image in a photo editor and re-save, you may reintroduce software tags or a new timestamp. Strip last, or strip again after any re-save.

Diagnose before you strip: read the table first

Don't strip blind. The fastest way to know whether you have a real problem is to look at what's actually in the file.

Drop one representative photo into the EXIF Remover and read the grouped table. You'll typically see:

GPS — latitude/longitude, sometimes altitude and direction
Camera — make, model, lens
Capture — timestamp, ISO, exposure
Software — the app or OS that last wrote the file

If GPS is present here, it will be present in the file you share. If it's absent here, your earlier strip probably worked and you were inspecting the wrong copy.

For a folder, spot-check two or three images rather than all of them. Cameras and phones write consistently, so if one has GPS, the batch almost certainly does.

The fix: batch strip without uploading

Here's the workflow that avoids the confusion above.

Collect the originals in one folder and don't touch them. Treat them as read-only.
Open the tool at toolkite.net/exif-remover and drag your files in — JPG, PNG, WebP, or HEIC (HEIC only if your browser can decode it). Nothing is uploaded; the reading and stripping happen in your browser.
Review the table on at least one file so you know what's being removed.
Hit Strip EXIF. The tool re-encodes the image via Canvas and produces a clean blob.
Download the cleaned files into a separate folder — name it something like clean/ so you never mix it up with the originals.
Verify. Re-open one cleaned file in the tool and confirm the GPS and camera rows are gone.

On the free tier you can process up to 10 photos per run. If you're cleaning a shoot, the optional Pro license raises that to 50+ per run and adds a privacy risk report with a score, plus CSV/JSON export of the metadata you found. That export is genuinely useful if you need to log what was in a batch before deleting it — for example, keeping a record of capture timestamps for a client while removing the location.

One honest caveat: because JPEG is re-encoded (quality around 0.92), the output is not bit-identical to the input. Visually it's fine for social, web, and client previews, but if you need pixel-perfect archival copies, keep the originals and treat the cleaned files as derivatives.

Prevention: stop the problem before it starts

A few habits make batch EXIF removal boring, which is what you want.

Strip at the end of your edit chain. Any re-save after stripping can reintroduce software tags.
Keep originals and cleaned files in separate folders. Most "it didn't work" reports are folder mix-ups.
Check HEIC before a big batch. Test one HEIC file first; if your browser can't decode it, convert to JPG beforehand rather than discovering it mid-run.
Don't assume selective removal. The tool strips all metadata in one pass — there's no GPS-only or keep-the-lens-info mode. If you need to preserve some fields, that's a job for a different tool.
Re-check after any third-party app touches the file. Editors and upload pipelines can write new metadata.

If your batch is part of a broader publishing workflow, it's worth pairing this with a watermark pass so branding and metadata cleanup happen in the same sitting. Watermark runs in the browser too, so the same no-upload rule applies.

When a browser tool isn't the right fit

Be honest about the limits. A browser-based stripper is excellent for social posts, client previews, and quick batches. It is not a forensic tool, and it doesn't claim to be.

If you need to inspect or remove metadata at a deeper level — obscure formats, scripted pipelines, or field-by-field control — command-line tools like ExifTool are the right call. They're slower to set up and less friendly, but they give you granular control this tool deliberately doesn't offer. Use the browser tool for the 90% case and reach for the CLI when you genuinely need surgical precision.

For anything involving sensitive files, remember the privacy angle: with a browser tool, the image never leaves your machine. That's the whole point. You can read more about how Toolkite handles data on the privacy page.

FAQ

Why does my photo still show GPS after I batch removed EXIF?

In most cases you're inspecting the original file, not the cleaned export. Browser tools leave the source untouched and produce a new download, so re-opening the file from your camera roll or Downloads folder shows the original metadata. Open the cleaned copy from your separate output folder instead, and re-check it in the tool.

How come some photos in my batch didn't get stripped at all?

Format is the usual reason. JPG, PNG, and WebP re-encode reliably, but HEIC only works if your browser can decode it. If a HEIC file can't be decoded, it may fail or be skipped in the batch. Test one HEIC file before running a large set, and convert to JPG first if needed.

What if I strip EXIF and then edit the photo again?

Re-saving in an editor or syncing through certain apps can write new metadata fields, including software tags and fresh timestamps. Strip as the last step in your workflow, or strip again after any re-save. Keeping originals and cleaned files in separate folders makes this easy to manage.

Does batch EXIF removal without uploading mean nothing leaves my device?

Yes — with a browser-based tool the file is read and re-encoded locally, and nothing is sent to a server. That's the core advantage over upload-based converters. You can read more about how data is handled on the Toolkite privacy page.

Is the cleaned image identical to the original?

Not bit-for-bit. JPEG output is re-encoded at roughly 0.92 quality, so there's slight recompression. It looks fine for social media, web, and client previews, but if you need pixel-perfect archival copies, keep the originals and treat the cleaned files as derivatives.

Can I remove only GPS and keep the camera info?

No — the tool strips all metadata in a single pass, so there's no GPS-only or keep-the-lens mode. If you need field-by-field control, a command-line tool like ExifTool is the better fit. The browser tool is built for quick, private, whole-file cleanup.

The Practical Way to a Browser Based Mock Data Generator No Upload

tavi — Thu, 10 Sep 2026 12:30:50 +0000

I was setting up a staging database last month and needed 5,000 realistic user records. Every generator I found wanted an email address, a workspace name, or a credit card before it would spit out a single row. One of them asked me to paste my schema into a form and hit "Generate" — which, as far as I could tell, shipped the whole thing to a server I'd never heard of.

If you're generating test data for anything that resembles a real product, that's a bad trade. Customer names, emails, and address shapes are exactly the kind of thing you don't want sitting in someone else's logs. A browser based mock data generator with no upload solves that by running the generation logic locally — the schema and the output never leave your machine.

That's the angle here: how to get realistic fake data fast, without signing up or handing your schema to a third party.

Why "no upload" actually matters for test data

It's easy to wave off privacy concerns when the data is fake. But the schema itself is often the sensitive part. If you're mocking a healthcare intake form, a fintech onboarding flow, or an internal HR tool, the field names alone tell a story about what your system does and what it stores.

There's also the practical side. Server-based generators introduce latency, rate limits, and the occasional 502 right when you're mid-sprint. A local generator just runs. You pick 10,000 rows, you get 10,000 rows.

A few things to keep in mind when you evaluate any generator:

Where does generation happen? If the answer is "on our servers," your schema is going somewhere.
What's the free ceiling? Many tools cap you at a few hundred rows and push you to a paid plan.
What formats can you export? JSON and CSV cover most workflows; SQL INSERT statements save a step if you're seeding a database.

Use our online tool: Mock Data Generator

The Mock Data Generator at Toolkite runs faker.js entirely in your browser. Nothing is uploaded, and there's no account to create. Here's the workflow:

Build a schema. Add fields one at a time and pick a type for each — name, email, address, date, and so on. The field list is the contract your fake data has to satisfy.
Generate. Choose how many rows you want. The free tier goes up to 20,000 rows and includes a limited set of field types (15 of them).
Export. Preview the result, then download it as JSON or CSV.

That's the whole loop. No signup wall, no "verify your email to continue." If you want to see how it compares to other browser-only tools on the site, the blog has more walkthroughs.

What the free tier covers

For most day-to-day work — seeding a dev database, populating a UI mockup, testing a CSV import — the free tier is enough. You get up to 20,000 rows and 15 field types. That's a real ceiling, not a demo.

If you need more, there's an optional Pro tier at $14.99 one-time. It unlocks unlimited rows, 30+ field types (including locale-specific data), the ability to save up to 20 schemas in IndexedDB, SQL INSERT export, multi-format ZIP export, and an ad-free experience. It's a one-time purchase, not a subscription — worth noting if you've been burned by per-seat pricing on other generators.

A quick schema example

Say you're mocking a user table. Your schema might look like:

id → UUID
first_name → first name
last_name → last name
email → email (derived from name, ideally)
signup_date → date within the last two years
country → country

Generate 5,000 rows, export as CSV, and you've got a file you can drop straight into a seed script. If you're feeding a Postgres instance, the Pro SQL INSERT export saves you a conversion step.

The alternative: SaaS generators and CLI scripts

There are two other paths people usually take, and both have honest trade-offs.

SaaS generators (Mockaroo and similar). These are polished, support a lot of types, and let you share schemas across a team. The catch is that your schema lives on their servers, the free tiers are usually row-limited, and you may need an account to save anything. If your org already has a data processing agreement with the vendor, fine. If not, think about whether the schema is something you'd be comfortable emailing to a stranger.

CLI scripts with faker.js or Faker. This is the most flexible option and the one I reach for when I need something highly custom. A minimal Node script looks like:

const { faker } = require('@faker-js/faker');
const rows = Array.from({ length: 5000 }, () => ({
  id: faker.string.uuid(),
  name: faker.person.fullName(),
  email: faker.internet.email(),
  country: faker.location.country(),
}));
console.log(JSON.stringify(rows, null, 2));

Run it, redirect to a file, done. The trade-offs: you need Node installed, you have to write and maintain the script, and you're responsible for your own locale handling. For a one-off, that's fine. For a quick mockup where you just want a CSV in thirty seconds, it's overkill.

A browser tool sits in the middle: no install, no upload, no account. You lose the scripting flexibility, but you gain speed.

Practical tips before you generate

A few things I've learned the hard way:

Match your real column names. If your production schema uses created_at, don't generate signup_date. Renaming columns later is annoying.
Think about referential integrity. If you're mocking orders and customers, you need the customer IDs in the orders file to actually exist. Generate the parent table first, then reuse those IDs.
Watch your date ranges. A signup_date that lands in 2047 will break any date filters in your app. Set sensible bounds.
Keep the schema file. If you're on the free tier, you'll be rebuilding the schema each session. On Pro, schemas save to IndexedDB in your browser, so you can pick up where you left off.
Don't generate more than you need. 20,000 rows is plenty for most tests. If you're hitting performance issues, it's usually the app, not the data volume.

When to pick which

If you're on a team with a signed vendor agreement and you need shared schemas across people, a SaaS tool makes sense. If you're scripting a repeatable data pipeline and you're comfortable in Node, write the script. If you just need realistic fake data in your browser, right now, without creating an account or uploading anything — that's exactly what the Mock Data Generator is for.

One more note on privacy: because generation happens locally, there's no server-side copy of your schema or your output. That's a meaningful difference from tools that generate on the backend. You can read more about how Toolkite handles data on the privacy page.

The short version: pick the tool that matches your workflow, but be honest with yourself about where your schema ends up.

FAQ

Does the Mock Data Generator send my schema to a server?

No. The generator runs faker.js locally in your browser, so your schema and the generated rows stay on your device. Nothing is uploaded, and there's no backend processing step involved.

How many rows can I generate for free?

The free tier supports up to 20,000 rows per generation, with a limited set of 15 field types. If you need more rows or additional field types like locale-specific data, there's an optional one-time Pro upgrade.

What export formats are available?

You can preview and download your generated data as JSON or CSV on the free tier. Pro adds SQL INSERT statements and multi-format ZIP export, which is handy if you're seeding a database directly.

Can I save my schema and reuse it later?

On the free tier, you'll rebuild the schema each session. Pro lets you save up to 20 schemas in IndexedDB, which is browser-local storage, so they persist between visits without any account.

Is this a good alternative to Mockaroo or a Node faker script?

It depends on your workflow. Mockaroo is strong for team-shared schemas but keeps data on their servers. A Node script gives you maximum flexibility but requires setup. A browser tool is the middle ground: no install, no upload, no account, just fast generation.

Do I need to create an account to use it?

No account is required. You can build a schema, generate rows, and export the result without signing up. The optional Pro upgrade is a one-time purchase if you want the higher limits and extra features.

The Practical Way to Deep Nested JSON to Flat CSV

tavi — Wed, 09 Sep 2026 12:30:26 +0000

If you've ever stared at a JSON file with objects nested three or four levels deep and thought, "I just need this in a spreadsheet," you know the pain. Manually flattening nested arrays and objects is tedious, error-prone, and a total time sink. But here's the thing: you don't need to write a custom script or upload your data to some random server. There's a way to flatten deep nested JSON to flat CSV right in your browser, without your file ever leaving your device.

In this walkthrough, I'll show you how to use Toolkite's JSON ↔ CSV Converter to flatten nested JSON into a clean, flat CSV—step by step. We'll also look at a command-line alternative for when you need more control, and I'll point out the trade-offs so you can pick what fits your workflow.

Why Flatten Nested JSON Is a Headache

Let's be honest: JSON is great for APIs, but it's not exactly spreadsheet-friendly. A typical API response might look like this:

{
  "order_id": 12345,
  "customer": {
    "name": "Jane Doe",
    "email": "jane@example.com",
    "address": {
      "city": "Portland",
      "zip": "97205"
    }
  },
  "items": [
    {"sku": "A1", "qty": 2},
    {"sku": "B2", "qty": 1}
  ]
}

To get that into a CSV, you need to decide how to represent customer.address.city and the items array. Most converters either choke on the nesting or just give you a mess of [object Object]. That's why you need a tool that knows how to flatten nested structures into columns like customer.name, customer.address.city, and so on.

How to Flatten Deep Nested JSON to Flat CSV in 5 Steps

Here's the exact workflow I use with Toolkite's converter. It's free for files up to 25MB and handles nesting up to 10 levels, which covers most real-world API payloads.

Step 1: Open the Converter and Paste or Upload Your JSON

Head over to the JSON ↔ CSV Converter. You'll see a text area where you can paste your JSON directly. If your JSON is in a file, just drag and drop it—no upload, no waiting. The tool processes everything locally in your browser, so your data never touches a server.

Step 2: Choose the Right Conversion Mode

You'll want to select JSON → CSV. If you're aiming for an Excel file instead, you can pick JSON → Excel (which gives you an .xlsx). For this guide, we'll stick with CSV.

Step 3: Flatten the Nested JSON (Pro Feature)

Here's the key: to flatten nested objects and arrays, you need the Flatten nested JSON option, which is part of Toolkite Pro. With Pro, you get deep flattening that turns nested structures into column headers like customer.address.city. The free version handles flattening up to 10 levels, but Pro removes that limit and gives you more control.

If you're only dealing with a shallow structure (a couple of levels), the free version might be enough. But for deep nesting—say, an API response with three or four levels—Pro is worth the one-time $9.99.

Step 4: Convert and Preview

Hit the convert button. The tool will process the JSON and show you the resulting CSV. You'll see columns for each flattened path, and rows for each object. If your JSON has arrays, the tool will repeat the parent data for each array element—a common approach that keeps everything in a flat table.

Step 5: Download or Copy the Result

Once you're happy with the preview, click Download to save the CSV file, or just copy the output to your clipboard. That's it. No sign-up, no upload, no server-side processing.

What About Arrays of Objects?

If your JSON is an array of objects (like a list of users), the converter handles that fine. Each object becomes a row, and nested fields become columns. If you have arrays inside objects, the tool will “explode” them—meaning it creates multiple rows for each item in the array, duplicating the parent fields. That's the standard way to flatten nested JSON to CSV, and it works well for most use cases.

Alternative: Using jq and a Spreadsheet (CLI Approach)

If you're comfortable with the command line, you can flatten nested JSON using jq and then import the result into Excel or Google Sheets. For example, to flatten a simple object with one level of nesting, you might use:

jq -r '. as $root | .items[] | [.sku, .qty, $root.order_id, $root.customer.name] | @csv' data.json

That gets messy fast with deeper nesting. You'd have to write complex jq filters or switch to a tool like pandas in Python. The trade-off is control: you can decide exactly how to flatten, rename columns, and handle edge cases. But it requires scripting knowledge and debugging time.

The browser tool, on the other hand, is instant and doesn't require any setup. For a one-off conversion, it's usually faster. For a recurring pipeline, a script might be worth the investment.

Privacy: Your Data Stays in Your Browser

One thing I really appreciate about Toolkite is that everything runs locally. When you use the JSON ↔ CSV Converter, your JSON is processed in your browser using libraries like PapaParse and SheetJS. There's no file upload, so sensitive data—customer info, internal API responses, whatever—never leaves your machine. That's a big deal if you're handling data under NDA or just prefer not to trust random online tools.

If you're curious about the privacy details, you can read more on the privacy page.

When to Go Pro

The free tier is generous: files up to 25MB and flattening up to 10 levels. That covers a lot of cases. But if you're dealing with deeply nested JSON (more than 10 levels), files larger than 25MB, or you need to batch-convert multiple files, Pro is a one-time $9.99 purchase. It also removes ads and adds features like custom delimiters and API URL fetching. For a freelancer or developer who regularly wrestles with API data, it's a solid investment.

Final Thoughts

Flattening deep nested JSON to CSV doesn't have to be a chore. With the right browser tool, you can do it in minutes, without uploading your data anywhere. Next time you're staring at a nested API response, give the JSON ↔ CSV Converter a try. Your future self will thank you.

FAQ

What does flatten nested JSON mean?

Flattening nested JSON means converting a hierarchical structure (objects within objects, arrays) into a flat table where each column represents a path, like 'customer.address.city'. This makes it easy to view in a spreadsheet or import into a database.

Can I flatten deeply nested JSON for free?

Yes, Toolkite's JSON ↔ CSV Converter is free for files up to 25MB and supports flattening up to 10 levels of nesting. If your JSON is deeper than that, you'll need the Pro version, which costs a one-time $9.99.

Does Toolkite upload my JSON to a server?

No. The conversion happens entirely in your browser using client-side libraries. Your data never leaves your device, which is great for privacy-sensitive information.

How does the tool handle arrays inside nested objects?

When flattening, arrays are typically 'exploded'—each array element becomes a separate row, with the parent object's fields repeated. This produces a flat CSV where every row is self-contained.

Can I convert nested JSON to Excel (.xlsx) instead of CSV?

Yes. The Toolkite converter offers a JSON → Excel mode that produces an .xlsx file. The same flattening logic applies, so you can get a spreadsheet with nested fields as columns.

What are the limitations of the free version?

The free version supports files up to 25MB and flattening up to 10 levels. It also shows ads. Pro removes ads, increases the file limit to 50MB, allows deeper flattening, and adds batch conversion and custom delimiters.

How to Check if a Photo Has GPS Data (Without Uploading It)

tavi — Tue, 08 Sep 2026 12:30:27 +0000

You've got a photo you're about to post or send, and a nagging thought: does this thing have my location baked in? Maybe it's a shot of your new apartment, a client's property, or a friend's backyard. The answer isn't always obvious from looking at the file. Here's how to check if a photo has GPS data — and do it without uploading it to some random server.

Why GPS Data Hides in Plain Sight

Most phones and many cameras embed EXIF metadata when they snap a picture. That metadata can include the camera model, lens, shutter speed, ISO, and — if location services are on — GPS coordinates. You don't see any of it in the image itself. It's just there, quietly attached to the file.

That's fine when you're the only one who sees the file. But if you share it on social media, send it to a client, or post it on a forum, those coordinates can travel with it. Some platforms strip metadata automatically; many don't. So before you share, it's worth knowing what's actually in the file.

How to Check if a Photo Has GPS Data in 5 Steps

Here's a practical, private way to check — and then clean up if needed — using the EXIF Remover tool on Toolkite. Everything runs in your browser, so the photo never leaves your device.

Step 1: Open the EXIF Remover tool

Head to https://toolkite.net/exif-remover/. You'll see a drop zone. No account, no sign-up, no upload.

Step 2: Drop your photo

Drag and drop a JPG, PNG, WebP, or HEIC file onto the page — or click to browse. The tool reads the metadata directly in your browser using a library called exifr. It doesn't send the file anywhere.

Step 3: Look for the GPS section

The tool displays the EXIF data in a grouped table. Scroll through it and look for headings like GPS or Location. If you see latitude and longitude values, your photo has GPS data. You'll also see other useful fields like camera model, timestamp, and software.

Step 4: Decide what to do

If there's no GPS data, great — you can safely share the original. If there is, you have two choices: keep the original for yourself, or strip the metadata before sharing.

Step 5: Strip and download (if needed)

Click the Strip EXIF button. The tool re-encodes the image by drawing it to a Canvas and exporting a new file, removing the metadata in the process. Then download the cleaned image. The original file on your disk stays untouched — you get a fresh, clean copy.

That's it. You've checked and, if necessary, removed the GPS data — all without uploading a single byte.

What About Checking on Your Phone or Desktop?

Sometimes you're not near a browser, or you just want a quick check without opening a tool. Here are a few alternatives:

Windows: Right-click the file, select Properties, then go to the Details tab. Look for "GPS" or "Latitude/Longitude" fields.
macOS: Open the photo in Preview, then go to Tools > Show Inspector (or press Cmd+I). Click the Exif tab and look for "GPS" or "Location".
iPhone/Android: In the Photos app, swipe up or tap the info button. Some apps show location; others hide it unless you export the original.

These methods work, but they only tell you if GPS data exists — they don't clean it. And if you're dealing with HEIC files on a PC, the built-in tools often can't read the metadata at all.

Why Browser-Based Checking Beats Uploading to a Random Site

You might be tempted to use one of those "EXIF viewer" websites that asks you to upload your photo. Think about what that means: you're sending your image — and its metadata — to a server you don't control. Even if the site claims to delete files after processing, you have no way to verify that. For sensitive photos, that's a privacy risk you don't need.

Toolkite's approach is different: the tool runs entirely in your browser. The photo is read and processed locally. Nothing is uploaded. That's the same reason I use it for client work — I can check and strip metadata without worrying about where my files are going.

A Quick Word on What Stripping Does (and Doesn't Do)

When you strip EXIF via the browser method, the tool re-encodes the image. That means the output is a new file with metadata removed. It's not a bit-for-bit copy of the original — JPEG re-encoding can slightly change the file, though quality is generally preserved. If you need pixel-perfect copies, you might want to keep the original and only share the cleaned version.

Also, note that this method removes the standard EXIF, GPS, and camera metadata. It's not a forensic-grade wipe of every possible metadata channel — for that, you'd need specialized software. But for everyday sharing, it's more than enough.

Ready to Check Your Photos?

The next time you're about to share a photo and wonder if it's got GPS data, you don't need to guess. Open EXIF Remover, drop the file, and look at the table. If you see coordinates, strip them in one click. It's free to use in the browser, with an optional Pro upgrade if you need to batch-process 50+ photos or export metadata as CSV/JSON.

Your photos, your location — keep them under your control.

FAQ

How can I tell if a photo has GPS data without uploading it?

Use a browser-based tool like Toolkite's EXIF Remover. Drop the photo onto the page, and it reads the metadata locally, displaying GPS coordinates if present. Nothing is uploaded to a server.

What does GPS data in a photo look like?

GPS data appears as latitude and longitude coordinates, often along with altitude and timestamp. In EXIF viewers, it's usually under a 'GPS' or 'Location' section.

Does stripping EXIF remove GPS data permanently?

Yes, when you use the Strip EXIF button, the tool re-encodes the image and removes the metadata, including GPS. The original file on your device remains unchanged, so you have a clean copy to share.

Can I check GPS data on my phone without an app?

On iPhone, open the photo and tap the info button or swipe up to see location if available. On Android, use the Gallery app's details or a file manager. These methods only show location if the app reads EXIF; they don't strip it.

Is it safe to use online EXIF viewers?

It depends. Many online viewers require uploading your photo to their server, which creates a privacy risk. Toolkite's EXIF Remover processes everything in your browser, so your photo never leaves your device.

Capitalize Text Online: The Practical Way to Fix Case Without Losing Privacy

tavi — Mon, 07 Sep 2026 12:30:46 +0000

We've all been there: you paste a block of text into some random website to capitalize it, and a tiny voice in your head asks, "Wait, is this thing sending my text to a server?" For most people, it doesn't matter—until it does. If you're a developer pasting API keys, a writer working on an unpublished draft, or a support agent dealing with customer data, that question matters a lot.

The good news? You don't need to upload your text anywhere. With a browser-side tool like Toolkite's Text Toolbox, you can capitalize text online while your content never leaves your device. But before you jump in, let's talk about the common mistakes people make when they try to fix text case online—and how to avoid them.

Mistake #1: Assuming Every Online Tool Processes Locally

This is the big one. Many "online" text tools actually send your text to a remote server, process it there, and send it back. That's fine for a grocery list, but not for a client's private notes or a snippet of proprietary code.

The fix: Look for tools that explicitly state they run in your browser. Toolkite's Text Toolbox processes everything client-side—your text stays in your browser's memory and never hits a network. You can paste sensitive content without worrying about where it's going.

Mistake #2: Using a Word Processor for Bulk Case Conversion

Word processors like Microsoft Word or Google Docs can change case, but they're clunky for bulk operations. You have to select text, navigate menus, and often you're limited to sentence case or title case. If you have a list of 500 product names that need to be uppercase, doing that in a word processor is a recipe for repetitive-stress injury.

The fix: Use a dedicated text utility. The Text Toolbox includes case conversion options like uppercase, lowercase, title case, and sentence case. Paste your list, pick the case you need, and copy the result in one go. No menu hunting, no formatting surprises.

Mistake #3: Relying on Social Media or Messaging Apps

Sometimes people type text in a chat app, use its built-in formatting, and then copy it elsewhere—only to find the case didn't stick. Or they paste text into a social media composer that auto-capitalizes the first letter of each sentence, mangling their intended formatting.

The fix: Don't rely on apps that have their own case logic. Use a neutral text tool that does exactly what you ask. Copy from your source, run it through a case converter, and paste the clean result into any app.

Mistake #4: Forgetting About Other Text Cleanup Tasks

Capitalization is rarely the only thing wrong with a block of text. You might also have duplicate lines, extra spaces, or inconsistent line endings. If you fix the case first, you might have to redo it after you remove duplicates or sort lines.

The fix: Do all your text cleanup in one place. Text Toolbox offers 20+ utilities—dedupe lines, sort, case convert, slugify, Base64 encode/decode, and more. You can run multiple operations in sequence without losing your original text. For example, you can sort a list, then convert it to title case, all in the same session.

Mistake #5: Ignoring the Privacy Implications of Your Text

Even if you're not handling top-secret data, your text can reveal a lot. A draft article might contain personal anecdotes. A CSV export might have customer emails. A log file might include internal IP addresses. Uploading that to a random server is a privacy risk you don't need to take.

The fix: Make it a habit to use browser-side tools for any text you'd rather not share. Toolkite's privacy-first approach means you can capitalize text online without uploading it. Check their privacy policy if you want the details, but the short version is: your text stays with you.

How to Capitalize Text Online with Text Toolbox

Ready to try it? Here's how to use Text Toolbox to change case, step by step:

Paste your text into the editor. You can drop it in or paste it directly. Everything stays local.
Pick a tool from the categories: Format, Transform, Generate, or Analyze. For capitalization, you'll likely want the case conversion tool under Transform.
Copy the result once you're happy. You can copy the transformed text or download it if you need to save it.

That's it. No sign-up, no upload, no waiting. The free version handles up to 2 million characters—plenty for most tasks. If you regularly work with larger files, there's an optional Pro upgrade (one-time $9.99) that supports up to 5MB, keeps a history of your last 20 operations, and enables batch processing for multiple blocks.

A Quick Note for Power Users

If you're comfortable with the command line, tools like sed or awk can also change case. For example, sed 's/.*/\U&/' will uppercase a line in Unix. But that requires you to have a terminal open, and it's not exactly beginner-friendly. A browser-based tool is faster for one-off tasks and doesn't require any setup.

Common Questions About Capitalizing Text Online

Can I capitalize text online without uploading my data?

Yes. Tools like Toolkite's Text Toolbox run entirely in your browser, so your text never leaves your device. You can paste sensitive content and process it locally.

What case options does Text Toolbox offer?

The Text Toolbox includes case conversion utilities that let you switch between uppercase, lowercase, title case, and sentence case, among others. You can apply these to any text you paste into the editor.

Is Text Toolbox free to use?

Yes, the basic version is free and supports up to 2 million characters per operation. There's also an optional one-time Pro upgrade for $9.99 that removes ads, increases the limit to 5MB, adds operation history, and enables batch processing.

Can I use Text Toolbox for other text cleanup tasks?

Definitely. It includes over 20 utilities, such as removing duplicate lines, sorting lines, generating slugs, and encoding/decoding Base64. You can handle multiple tasks in one place.

Does Text Toolbox work on mobile devices?

Since it's browser-based, it works on any device with a modern browser, including phones and tablets. The interface is responsive, so you can capitalize text on the go.

What happens if I close the browser tab while using Text Toolbox?

Your text is processed in the browser's memory, so if you close the tab, the processed result is gone. Make sure to copy or download your output before closing. The Pro version's history feature can help you recover past operations, but it's still a good idea to save important work.

FAQ

Can I capitalize text online without uploading my data?

Yes. Tools like Toolkite's Text Toolbox run entirely in your browser, so your text never leaves your device. You can paste sensitive content and process it locally.

What case options does Text Toolbox offer?

Is Text Toolbox free to use?

Can I use Text Toolbox for other text cleanup tasks?

Definitely. It includes over 20 utilities, such as removing duplicate lines, sorting lines, generating slugs, and encoding/decoding Base64. You can handle multiple tasks in one place.

Does Text Toolbox work on mobile devices?

Since it's browser-based, it works on any device with a modern browser, including phones and tablets. The interface is responsive, so you can capitalize text on the go.

What happens if I close the browser tab while using Text Toolbox?

How to Batch Watermark Photos Online Free (Without Uploading Files)

tavi — Sun, 06 Sep 2026 12:40:51 +0000

Why Batch Watermarking Without Uploading Matters

If you're a photographer or a small business owner who shares product shots on social media, you've probably spent an evening adding the same text watermark to fifty photos one by one. It's tedious, and if you use a typical "free" online tool, you're also handing your original files to a stranger's server. That's not just a privacy risk — it can also be a legal headache if those photos are client work.

Toolkite's Image Watermark tool does the whole job in your browser. Your photos never leave your device. No upload, no waiting for a server queue, no risk of someone else's hands on your files. The free version handles one image at a time, but if you need true batch processing, there's an optional Pro mode that unlocks it along with a few other useful features. Here's how to get it done, step by step.

How to Batch Watermark Photos Online Free: Step by Step

Step 1: Open the Image Watermark Tool

Head to the Image Watermark page in your browser. You don't need to create an account or sign in — just open the page and you're ready. Since everything runs locally, you can even use it offline if you've already loaded the page once.

Step 2: Upload Your Image (or Images)

Drop a photo onto the page. The tool accepts common image formats like PNG, JPG, and WebP, and it processes the file using canvas compositing right on your device. If you're on the free tier, you'll work with one image at a time. That's fine for a quick watermark on a single hero shot, but if you have a folder full of images to protect, you'll want the Pro batch mode.

Step 3: Style Your Watermark

Here's where you get creative. You can add a text watermark — type in your name, your brand, or a copyright notice — or upload a logo to use as a graphic watermark. Then adjust the font, size, color, opacity, rotation, and position using the 9-grid placement. The live preview updates as you tweak, so you can see exactly how the watermark will look before you export. No more guessing and re-exporting.

Step 4: Export Your Watermarked Image

Once you're happy with the preview, choose your export format: PNG, JPG, or WebP. You can also pick the quality level. The download happens instantly because the file never left your machine. For a single image, that's it.

Step 5: Upgrade to Pro for True Batch Watermarking

If you need to watermark dozens or hundreds of photos in one go, the Pro version is a one-time purchase of $14.99 (no subscription). With Pro, you can batch watermark up to 100 images at once, use tiling mode to cover the whole image with a repeating watermark, export up to 4K resolution, and save up to 10 custom templates plus 15 presets for future jobs. That's a solid deal for a freelancer who watermarks client galleries regularly.

Alternative: Batch Watermarking with ImageMagick (Command Line)

If you're comfortable with the command line, ImageMagick is a free, open-source alternative that runs locally. Here's a basic command to add a text watermark to every JPEG in a folder:

for img in *.jpg; do
  convert "$img" -gravity southeast -pointsize 36 -fill "rgba(255,255,255,0.5)" -annotate +20+20 "© YourName" "wm_$img"
done

This approach is powerful and scriptable, but it has a steep learning curve. You need to install ImageMagick, learn its syntax, and handle edge cases like different image sizes or fonts. The Toolkite browser tool gives you a visual preview and doesn't require any setup — you just drag, drop, and download.

Privacy and Practical Tips

No upload means no data breach risk. When you use a web tool that uploads your photos, you're trusting that server to delete them afterward. With Toolkite, there's nothing to delete — the file stays in your browser's memory until you close the tab.
Batch mode saves hours. If you're watermarking a wedding gallery or a product catalog, doing it manually is a huge time sink. The Pro batch mode is worth the one-time fee if you do this regularly.
Tiling mode for extra protection. If you're posting images that might be screenshotted or reused without credit, tiling the watermark across the entire image makes it much harder to crop out.
Check your export format. PNG is great for logos and graphics, but JPG is usually smaller for photos. WebP is a good middle ground for web use.

What About Removing Watermarks?

If you're looking to remove watermarks from someone else's photos, that's a different matter — and not something Toolkite offers. Watermark removal without permission is usually a copyright violation, so we won't go there. If you accidentally added a watermark to the wrong file, you can always re-export the original from your camera or backup.

Wrapping Up

Batch watermarking photos online free doesn't have to mean sacrificing your privacy or your sanity. With Toolkite's Image Watermark, you get a clean, visual workflow that runs entirely in your browser. Start with the free single-image mode to test it out, and if you need to process a whole batch, the Pro upgrade is a small one-time cost that pays for itself in saved time.

While you're at it, if you share photos publicly, you might also want to strip sensitive metadata like GPS coordinates before posting. Toolkite's EXIF Remover does that locally too, so your photos stay clean and private from start to finish.

FAQ

Is batch watermarking really free with Toolkite?

The free version of Toolkite's Image Watermark tool lets you watermark one image at a time. True batch processing (up to 100 images at once) is a Pro feature that costs a one-time $14.99. So you can try the tool for free, but for batch work you'll need the Pro upgrade.

Can I watermark multiple images at once without uploading?

Yes, with the Pro version of Toolkite's Image Watermark, you can batch watermark up to 100 images in one go. All processing happens in your browser — your photos are never uploaded to any server.

What file formats can I export after watermarking?

Toolkite's Image Watermark lets you export your watermarked images as PNG, JPG, or WebP. You can also adjust the quality before downloading.

Does Toolkite store my photos on a server?

No. Toolkite tools run entirely in your browser using canvas compositing. Your images never leave your device, so there's no server storage and no risk of data breach.

Can I use a logo as a watermark?

Yes, the Image Watermark tool supports both text and logo watermarks. You can upload your logo and adjust its opacity, rotation, size, and position with a live preview.

What is tiling mode in the Pro version?

Tiling mode repeats your watermark across the entire image in a grid pattern. This is useful if you want to make it very difficult for someone to crop out your watermark. It's available in the Pro version of the tool.

Photo Metadata Privacy Risks: A Checklist Before You Share

tavi — Sat, 05 Sep 2026 12:38:25 +0000

Why Photo Metadata Is a Privacy Risk

Every time you snap a photo, your camera or phone quietly records a pile of extra information alongside the pixels. That's EXIF (Exchangeable Image File) data, and it can include the exact GPS coordinates, the date and time, the camera model, lens settings, and sometimes even your name or software used. Most people never think about it — until a photo they posted online reveals their home address or a client's private location.

The scary part is how easy it is to leak. You might share a photo on social media, send it to a client, or upload it to a forum. Many platforms strip metadata automatically, but not all do. Some keep the EXIF intact, and even a single photo can expose more than you intended. That's why understanding photo metadata privacy risks is the first step to protecting yourself.

What's Actually Inside Your Photo's Metadata?

Before you can fix the problem, it helps to know what you're dealing with. Here's what typical EXIF data contains:

GPS coordinates – Latitude and longitude, often precise enough to point to your front door.
Camera info – Make, model, lens, focal length, aperture, shutter speed, ISO.
Date and time – When the photo was taken, sometimes down to the second.
Software – The editing app or firmware used.
Thumbnail – A small embedded preview that might contain its own metadata.
Copyright and author – If you've set it, your name or handle could be embedded.

Even if you think you've removed the visible location tag, the EXIF might still be lurking. That's why a proper metadata check is essential.

The Photo Metadata Privacy Checklist

Here's a practical checklist to run through before you share any photo, whether it's a personal snapshot or a client deliverable. Print it, bookmark it, or keep it in your head — just use it.

[ ] Identify which photos contain sensitive metadata – Start by checking a few images from each device or camera.
[ ] Check for GPS coordinates – If you're at home, at a client site, or anywhere private, that's a red flag.
[ ] Look for camera and software info – Not always a privacy risk, but it can reveal your workflow.
[ ] Decide if you need to strip all metadata – For most sharing scenarios, the answer is yes.
[ ] Strip EXIF before uploading – Use a tool that removes metadata without uploading your file to a server.
[ ] Verify the cleaned file – After stripping, check that the metadata is really gone.
[ ] Keep the original file safe – You might want the metadata later for your own records.
[ ] Be aware of platform behavior – Some social sites strip metadata, others don't. Don't rely on them.

How EXIF Remover Covers the Critical Items

If you're looking for a way to handle this without sending your photos to some random server, EXIF Remover on Toolkite does the job entirely in your browser. That's a big deal for privacy — your files never leave your device.

Here's how it works in practice:

Drop your photo – Drag and drop a JPG, PNG, WebP, or HEIC file, or click to browse. Nothing is uploaded.
Review the EXIF fields – You'll see GPS coordinates, camera model, lens, timestamp, ISO, and software in a grouped table. This is your chance to see exactly what's embedded.
Strip & download – One click removes all metadata. The tool re-encodes the image (JPEG quality around 0.92) and gives you a clean file ready for sharing.

The original file on your disk is untouched — you get a new, cleaned image. That's perfect for keeping your own records while sharing a safe version.

What It Doesn't Do (and Why That's Okay)

EXIF Remover doesn't offer selective removal — you can't keep the lens info while dropping GPS. It strips everything, which is actually the safest approach for most people. It also doesn't claim forensic-grade wiping of every possible metadata channel, but for everyday sharing, it's more than enough.

If you need to handle obscure formats or want finer control, you might look at command-line tools like ExifTool. But for a quick, private, browser-based solution, EXIF Remover covers the essentials.

The Privacy Advantage of Browser-Based Tools

When you use an online tool that uploads your photos to a server, you're adding another party to the equation. Even if they promise to delete files, you're trusting them with your data. Browser-based processing eliminates that risk entirely.

Toolkite's whole approach is privacy-first — all tools run 100% in the browser with zero file upload. That means your photos, with all their sensitive metadata, never leave your computer. It's the difference between handing your photo to a stranger and keeping it in your own pocket.

Practical Tips for Different Scenarios

Sharing on Social Media

Before you post that picture of your new apartment or your weekend hike, strip the EXIF. Some platforms like Instagram and Facebook remove metadata, but others like Flickr or certain forums don't. Don't gamble with your location.

Sending Photos to Clients

If you're a freelancer or photographer, you might want to send a clean image without your camera settings or GPS data. EXIF Remover's free tier handles up to 10 photos per run, which is fine for a quick share. For larger batches, the optional Pro upgrade lets you process 50+ photos at once and even gives you a privacy risk report with a score.

Archiving Your Own Photos

You might actually want to keep the original file with its metadata for your own records. That's why EXIF Remover creates a new file instead of overwriting the original. You get the best of both worlds.

Final Thoughts

Photo metadata privacy risks are real, but they're also easy to mitigate. A quick check and a one-click strip can save you from awkward or even dangerous leaks. The key is to make it a habit before you hit share.

Next time you're about to upload a photo, run through the checklist above. And if you need a fast, private way to clean your images, give EXIF Remover a try. It's free to use in the browser, with optional Pro upgrades if you need more power. Your privacy is worth the few seconds it takes.

FAQ

What is photo metadata and why is it a privacy risk?

Photo metadata, often called EXIF, includes details like GPS coordinates, camera model, timestamp, and software. It's a privacy risk because it can reveal your exact location, device, and habits when you share photos online, sometimes without you realizing it.

Does social media strip photo metadata automatically?

Some platforms like Facebook and Instagram remove EXIF data when you upload, but not all do. Sites like Flickr or certain forums may keep it intact. It's safer to strip metadata yourself before posting, rather than relying on the platform.

How can I check if my photo has GPS data?

You can use a browser-based tool like EXIF Remover on Toolkite to view all EXIF fields, including GPS coordinates. Just drop your photo in, and it will show you a grouped table of metadata without uploading your file anywhere.

Is it safe to use an online EXIF remover?

It depends on the tool. Many online services upload your photos to a server, which adds risk. Toolkite's EXIF Remover processes everything in your browser with zero upload, so your files never leave your device. That's the safest option.

Can I remove only GPS data and keep other metadata?

EXIF Remover doesn't offer selective removal — it strips all metadata in one click. That's actually recommended for privacy, as it ensures nothing sensitive remains. If you need to keep certain fields, you'd need a more advanced tool like ExifTool.

Does stripping EXIF affect photo quality?

Stripping metadata by re-encoding the image can cause a slight recompression, especially for JPEGs. EXIF Remover uses a quality setting around 0.92, so the visual difference is usually negligible. The original file is never altered, so you can always keep a high-quality version.

How to Convert JSON to CSV with Headers (Without Uploading Your Files)

tavi — Fri, 04 Sep 2026 12:30:20 +0000

If you've ever stared at a JSON file and wished it looked like a spreadsheet, you're not alone. The good news: converting JSON to CSV with headers doesn't have to involve uploading your data to some random server or wrestling with command-line tools. You can do it right in your browser, and your file never leaves your device.

I've spent way too many hours fighting with JSON-to-CSV converters that either choke on nested objects or ask for an email address before they'll let you download the result. That's why I switched to a browser-based approach. Let me show you how it works.

Why Headers Matter in JSON to CSV Conversion

CSV files need a header row to be useful. That's the first line with column names like name, email, date. Without headers, you're just dumping values into a file with no context — and that's a nightmare for anyone trying to import it into Excel, Google Sheets, or a database.

When you convert JSON to CSV, the keys in your JSON objects become the headers. For example, this JSON array:

[
  {"name": "Alice", "age": 30},
  {"name": "Bob", "age": 25}
]

should become:

name,age
Alice,30
Bob,25

Seems simple, right? But things get tricky when you have nested objects or arrays inside your JSON — which is exactly where most online converters fall apart.

The Problem with Nested JSON

If you're working with data from an API, it's probably nested. Maybe you have something like this:

{
  "orders": [
    {
      "id": 101,
      "customer": {
        "name": "Alice",
        "email": "alice@example.com"
      }
    }
  ]
}

A naive converter would probably just give you a single column with [object Object] in it — useless. Or it might flatten only the top level, missing the customer's name and email entirely.

That's where flattening comes in. You want the nested fields to become their own columns, like customer.name and customer.email. The Toolkite JSON↔CSV converter can do this automatically, and it's free for files up to 25MB with flattening up to 10 levels deep. That covers most real-world use cases I've seen.

Use Our Online Tool: Convert JSON to CSV with Headers in 3 Steps

I'm going to walk you through using the JSON ↔ CSV Converter on Toolkite. It's free, runs entirely in your browser, and doesn't require an account.

Here's how to do it:

Paste or upload your JSON. You can copy-paste your JSON directly into the text area, or you can drag and drop a .json file. The free tier handles files up to 25MB, which is plenty for most API responses.
Choose the conversion direction. Select JSON → CSV (or JSON → Excel if you want an .xlsx file instead). If you have nested objects, the tool will flatten them by default — you can control the depth in the settings.
Download your CSV. Once the conversion is done, you'll see the result, and you can either copy it or download the .csv file. Your original JSON never leaves your browser.

That's it. No sign-up, no file upload to a server, no waiting for an email with a download link.

If you need to convert multiple files at once or want to fetch JSON directly from an API URL, that's a Pro feature (one-time payment of $9.99). But for most one-off conversions, the free version is all you need.

Alternative Method: Using Python's csv Module

If you're comfortable with a bit of code, you can also convert JSON to CSV with headers using a Python script. Here's a simple example that handles flat JSON:

import json
import csv

# Load your JSON
with open('data.json') as f:
    data = json.load(f)

# Write CSV
with open('output.csv', 'w', newline='') as f:
    writer = csv.DictWriter(f, fieldnames=data[0].keys())
    writer.writeheader()
    writer.writerows(data)

This works fine for flat data, but once you introduce nesting, you'll need to write a flattening function yourself — which is more code and more potential for bugs.

The trade-off is clear: a script gives you full control, but it takes time to write and debug. A browser tool is instant and handles edge cases for you, but you're trusting the tool to do the flattening correctly. For most people, especially those who don't code every day, the browser approach is faster and less error-prone.

Practical Tips and Edge Cases

When you're converting JSON to CSV, watch out for these gotchas:

Inconsistent keys. If some objects have extra fields, the CSV will have empty cells for those missing values. That's fine, but make sure your tool doesn't crash.
Arrays of objects vs. a single object. If your JSON is just one object, not an array, you might need to wrap it in brackets [...] for proper conversion.
Special characters. Commas and quotes inside your data will be escaped automatically by good converters, so you don't have to worry about breaking the CSV format.
Large files. If your file exceeds 25MB, you'll need the Pro version (up to 50MB) or you can split the file into smaller chunks.

Wrapping Up

Converting JSON to CSV with headers doesn't have to be a headache. Whether you're dealing with a flat array or deeply nested API response, you have options. The browser-based approach from Toolkite is privacy-friendly, free for most use cases, and handles nesting without you writing a single line of code.

Next time you need to turn JSON into a spreadsheet, give it a try — your data stays on your machine, and you'll have your CSV in seconds.

FAQ

What does 'convert JSON to CSV with headers' mean?

It means taking JSON data and turning it into a CSV file where the first row contains column names (headers) derived from the JSON keys. This makes the CSV readable by spreadsheet applications like Excel or Google Sheets.

Can I convert nested JSON to CSV with headers?

Yes, if you use a tool that flattens nested objects. The Toolkite JSON↔CSV converter flattens nested JSON up to 10 levels deep for free, turning nested fields like 'customer.name' into separate columns.

Does the Toolkite JSON↔CSV converter upload my data to a server?

No. All processing happens locally in your browser using JavaScript libraries. Your JSON file never leaves your device, which is why it's a privacy-friendly option.

Is there a file size limit for the free JSON to CSV conversion?

Yes, the free tier supports files up to 25MB. If you need to convert larger files (up to 50MB), you can upgrade to Pro for a one-time fee of $9.99.

Can I convert JSON to Excel (.xlsx) instead of CSV?

Yes, the same tool lets you choose JSON to Excel, which gives you an .xlsx file. This is handy if you need formatting or multiple sheets, though CSV is simpler for plain data.