GeoJSON vs Shapefile: Which Format Should You Use?

Both formats hold the same kind of thing: shapes on a map, with facts about each shape. Both open in real tools. Yet they come from two different eras, and the choice between them shapes your work more than most people expect — in file counts, field names, web use, and plain risk of loss.

This guide gives a fair, side-by-side account. The Shapefile is not a villain and GeoJSON is not magic. Each wins on its home ground. You can convert between the two formats in your browser either way, so the choice is never a trap: pick for the job in front of you, and convert when the job changes.

Read the table first if you are in a hurry. Read the rest if the data matters and will live for years. The last part gives a short rule of thumb for the four jobs we see most: web maps, office hand-over, field work, and archives.

Two Eras, Two Designs

The Shapefile was designed in the early 1990s, for desktop programs on one machine. It stores shapes in packed binary form, facts in a table file borrowed from old database tools, and an index in a third file. That design was fast and sound for its time. Its limits — 10-letter field names, one shape type per file, a set of parts that must travel together — are the limits of that era, kept alive because so much data and so many tools still speak the format.

GeoJSON was designed in the web era, and set as a standard in RFC 7946 in 2016. It stores shapes and facts in one text file that any web page, script, or API can read with no special library. Field names can be long. Text is UTF-8 from end to end. Its strict rule is the mirror of its design: coordinates are always WGS 84 longitude and latitude, because the web needed one shared assumption more than it needed options.

Neither design is 'better' in the abstract. A format is a fit between data, tools, and readers. The rest of this guide is about fit. Where the two truly differ in risk is silence: a Shapefile job can cut a field name with no warning in a careless tool, and a GeoJSON job can bloat to ten times the size with no warning at all. A good converter reports both, which is why the checks in our conversion guides lean so hard on reports.

The Third Option Most Teams Miss

Teams often frame the choice as two-way and then suffer the loser's limits. There is a third format that takes the master role from both: GeoPackage. One file, many layers, long field names, stored coordinate systems, and database strength for large data. QGIS and ArcGIS both work with it. It does not run on the web, and old tools may not read it — which is fine, because a master is not a hand-over form.

The pattern that ends most format fights is: master in GeoPackage, publish in GeoJSON for the web, export in Shapefile for offices that demand it, and KML for Google Earth. Each job gets the format that fits it, and no job forces its limits on the others. The third option many teams pick, GeoPackage, has its own full guide on this site.

If your world is small — one person, one tool, one kind of job — one format is enough, and this guide's table will tell you which. The master-and-copy pattern earns its keep when data changes hands, changes tools, or must still make sense in five years. Most project data does all three.

Words to Know

The layer and the ZIP carry the biggest differences between the two formats. Start there.

• Feature. one real thing on the map, such as one park, one road, or one shop. A file can hold many features.
• Attribute. a fact about a feature, stored as text or a number. A park has a name. A road has a speed limit. Those facts are attributes.
• Layer. one set of features of one kind, shown as one sheet on a map. A city file may hold a roads layer and a parks layer.
• Coordinate system (CRS). the rule that says what the numbers in a file mean. It tells a program where each point sits on Earth. Without it, numbers are just numbers.
• ZIP file. one packed file that holds many files in it. A Shapefile needs a ZIP, since a Shapefile is three or more files that must travel as one set.

The Short Answer, by Job

If you must decide in one minute, decide by the next tool that will touch the data:

• Web map, API, or app: GeoJSON. It is the native input of web map libraries.
• ArcGIS or a classic QGIS project that already runs on Shapefiles: Shapefile, or GeoPackage if the project can take it.
• Hand-over to a government office: ask. Many still name Shapefile in their rules; some now take GeoPackage.
• Long-term store of your own project data: GeoPackage as master, with GeoJSON or Shapefile exports as needed.

Notice that 'what my data is' does not appear in the list. Points, lines, and polygons live happily in both formats. The decider is always the reader and the tool. That is why the worked table in the next part scores the formats on handling, not on data: the data is the same; the handling is not. When you are ready to act, the step-by-step Shapefile to GeoJSON guide covers the most common move in full.

Side by Side: The Same Town Data in Both Formats

One town dataset — 3 layers, 8,400 features, 22 fields, several with long names — stored each way. The facts below are the kind you can test on your own data in an afternoon:

Read the size row with the right worry. GeoJSON text is larger, and for a web page that means slower loads on huge files. Past a few megabytes, serve the GeoJSON packed, or thin the geometry for the web copy while the full data stays in the master. Read the web row with the right worry too: a Shapefile cannot go on a web map at all until it is converted, so 'we use Shapefiles' always hides a conversion step somewhere in the chain.

Read the coordinate row as a trade, not a win. GeoJSON's one-system rule kills a whole class of errors — no lost .prj, no label lies — and also kills your choice. If your work must be stored in a local grid for true areas, GeoJSON cannot be the master. That one fact settles the master question for survey-grade teams, and it is why GeoPackage exists.

Keep Your Source Safe

Work on a copy, not on your only file. Save the first file in a safe place and do not change it. If a test goes wrong, you can start again from the clean source. This sounds like a small point, but it saves more work than any other habit in this guide.

Give each test a clear name. A name like test-1 tells you the order of your tries. A name like final-final-2 tells you nothing at all. When you find the settings that work, write them down in a short note next to the files. The next file of the same kind will then take minutes, not an hour.

How to Choose, in Five Questions

Answer these five questions in order. Most projects are decided by question two. Write the answers in the project note, so the next person does not reopen the debate from zero.

Step 1: Who or what reads the data next?

Name the tool and the reader, in words. 'The public web map' means GeoJSON. 'The county GIS office, ArcGIS' means Shapefile or GeoPackage — ask them which. 'Our own team, next year' means a master format, and points away from both hand-over forms. A choice made for a named reader can be defended. A choice made for 'GIS in general' cannot.

Step 2: Must the data open on the web with no server work?

If yes, the answer is GeoJSON, and the debate is over. Web libraries take it raw. If the web view can go through a server or a build step, the master can be anything sound, since conversion at publish time is cheap and can be automated on the Pro plan's API.

Step 3: Do field names or text carry meaning you cannot lose?

Long names, names in more than one language, and codes that must match other systems all argue against Shapefile as the store. Its 10-letter cap and old text code are not faults you can configure away. If a partner demands a Shapefile copy, make the copy — with a written rename list — and keep the true names in the master, as step-by-step GeoJSON to Shapefile shows.

Step 4: How large is the data, and how often does it change?

Small, still data travels well in any format. Large or fast-changing data wants a database form as master — GeoPackage — because text files get heavy and Shapefile parts cap at 2 GB each for safe use. Change rate matters too: a file edited daily should not be a file whose parts can be lost weekly.

Step 5: What must still work in five years?

Archives want open standards with public specs and many readers. GeoJSON (RFC 7946), GeoPackage (OGC), and even the Shapefile — whose spec is public and whose readers are everywhere — all pass that test. What fails archives is not a format. It is a missing coordinate note, a rename list no one kept, and a master no one marked. Write the note. Mark the master.

How to Check Your Result

Never trust a conversion you have not checked. The good news is that a sound check takes just a few minutes, and it is the same each time you work on a format choice.

First, match the counts. The report shows how many features went in and how many came out. The two counts should be the same. If the output count is lower, a step dropped data, and you should find out why before you share the file.

Next, look at the map preview. Your data should sit in the right town, state, or sea. If it sits in the ocean, or on the wrong side of the world, the coordinate system is the prime suspect. Zoom in on one place you know well and check that roads, parks, or points fall where they should.

Then check the fields. Open the field list in the report and read the names. Make sure the key fields are still there, with the right names and the right kind of values. Pick one feature you know and match each value back to the source by hand.

• Test the choice: convert a real file each way and open both results in the true next tool. Ten minutes of test beats a month of debate.
• Check the hand-over with the reader, not just the file. Ask the office or partner to open the test file and confirm it works in their hands.
• Write the decision and its reason in the project note, with the date. Format debates restart when reasons are lost.

Last, keep the source file. Save the result with a clear name that holds the date and the format, like parks-geojson-2026-11-07.zip. Keep the source and the result in one folder. If a question comes up next month, you can trace each feature back to where it came from.

Common Mistakes and How to Fix Them

Picking by Habit: 'We Have Always Used Shapefiles'

Habit is not a reader. If the next tool is a web map, the habit hides a conversion step, a rename risk, and a parts risk in every cycle. Keep the habit for the office copy if you like — and let the web copy be GeoJSON from a sound master.

Picking GeoJSON as the Master for Survey Work

GeoJSON stores degrees only. Areas and lengths counted from degrees distort, more so far from the equator. If your team's core work is measuring, the master must live in a local flat system. Store in GeoPackage in that system; publish GeoJSON copies for viewing.

Sending a Shapefile as Loose Parts

However the format debate ends, a Shapefile sent loose is a broken file waiting for its moment. Always ZIP the set. Better: send the ZIP plus a GeoJSON copy, so the reader has a form that cannot break in transit even if their tools are old.

Letting the Tool Rename Fields in Silence

On the GeoJSON-to-Shapefile road, names will shrink. The error is not the shrink; it is the silence. Use a converter that lists every rename, keep the list with the file, and keep the full names alive in the master. A rename list turns a loss into a mapping.

One Format for Every Job, Forever

The web wants text. The office wants its standard. The archive wants a marked master. Forcing one form on all three means two of them get a poor fit every time. Conversion is cheap and checked. Copies are not a mess when one master is marked — they are how data serves many readers well.

What the Plans Allow

You can start free. The Free plan gives you 5 conversions a month, with one file at a time and a size limit of 25 MB per file. That is enough to test a town dataset that must serve many readers on real data and check the result with care.

Starter costs $9 a month. It gives you 200 conversions a month, files up to 500 MB, and batch jobs of up to 10 files at once. Pro costs $19 a month. It gives you 1,000 conversions a month, files up to 5 GB, batch jobs of up to 25 files, and API access for work you run on a schedule. You can see what each plan includes before you pick.

All plans work the same way at the core. You get a map preview, feature counts in and out, and a clear report if a file has a fault. Your files are kept for 72 hours so you can download them again, and then they are deleted.

Frequently Asked Questions

Which format is more accurate?

Neither. Accuracy lives in the data and its coordinate system, not in the container. The same points store the same numbers in both, to the precision each holds. What differs is the risk around the data: lost parts and cut names on one side, size and a fixed system on the other.

Which files are smaller?

Shapefiles, most often, since the shapes are packed binary. GeoJSON is plain text and commonly runs two to five times larger for the same data. Packed for sending, the gap shrinks. For very large data, both lose to a database form like GeoPackage.

Can GeoJSON hold as much data as a Shapefile?

It can hold the same features, but the text form gets heavy and slow to load past tens of megabytes. Web copies should be sized for the web. Keep the full data in the master and export web-sized GeoJSON, thinned if the job allows it.

Why do offices still ask for Shapefiles?

Because their tools, rules, and archives were built on it over 30 years, and the format still works for desktop GIS. Standards change slowly where legal records are involved. Serve the office its Shapefile copy — checked, zipped, with a rename list — and keep your master in a modern form.

If I can have only one, which should it be?

For a web-facing life: GeoJSON. For a desktop GIS life with office hand-overs: GeoPackage as the store, if you truly may have one file type, since both QGIS and ArcGIS read it and exports cover the rest. If your tools are old and Shapefile-bound, keep Shapefiles — zipped, noted, and with the .prj guarded like data, because it is.

Final Checklist

Run through this short list before you share your file:

• The next reader and tool are named, and the format fits them.
• Field names and text survive in the chosen store, or a rename list is kept.
• The coordinate needs are met: WGS 84 for web, local grid for measuring.
• A test file was opened by the true reader, in the true tool.
• The master is marked, and the decision and its reason are in the project note.

If each point passes, your file is ready to use.

References

• https://www.rfc-editor.org/rfc/rfc7946 — RFC 7946, the GeoJSON specification. It sets the format's rules, including the fixed WGS 84 coordinate system.
• https://www.loc.gov/preservation/digital/formats/fdd/fdd000280.shtml — The Library of Congress format note for the ESRI Shapefile, covering its parts, limits, and history.
• https://gdal.org/en/stable/drivers/vector/shapefile.html — The GDAL Shapefile driver notes, a practical source for the format's field and size limits.