How do geospatial queries work in MongoDB?

Question

Accepted Answer

MongoDB has built-in support for **geospatial data and queries** — storing locations (points, areas) and querying by proximity, containment, and intersection. It uses **2dsphere indexes** and GeoJSON, powering features like "find places near me" without a separate geospatial database.

## Storing location data (GeoJSON)

```js
// store locations as GeoJSON points: [longitude, latitude] (note the order!)
db.places.insertOne({
  name: "Cafe",
  location: { type: "Point", coordinates: [-73.97, 40.77] }   // [lng, lat]
});

// create a 2dsphere index to enable geospatial queries
db.places.createIndex({ location: "2dsphere" });
```

Locations are stored as **GeoJSON** (`{ type: "Point", coordinates: [lng, lat] }` — longitude first), and a **2dsphere index** enables efficient geospatial queries on a sphere (Earth).

## Proximity queries — find nearby

```js
// $near — find documents near a point, SORTED by distance
db.places.find({
  location: {
    $near: {
      $geometry: { type: "Point", coordinates: [-73.97, 40.77] },
      $maxDistance: 1000        // within 1000 meters
    }
  }
});
// → results ordered nearest-first (great for "places near me")
```

`$near` finds documents near a point, returned in order of distance — the foundation of "nearby" features.

## Containment and intersection

```js
// $geoWithin — find documents INSIDE an area (polygon, circle)
db.places.find({
  location: {
    $geoWithin: {
      $centerSphere: [[-73.97, 40.77], 5 / 6378.1]   // within 5km radius
    }
  }
});

// $geoIntersects — find documents whose geometry intersects a given shape
db.zones.find({ area: { $geoIntersects: { $geometry: somePolygon } } });
```

`$geoWithin` finds documents inside an area (polygon/circle); `$geoIntersects` finds geometries that intersect a shape — for region-based queries.

## Why it matters

Geospatial query support is a valuable MongoDB capability for **location-based features**, so understanding it is useful knowledge for applications dealing with locations (maps, delivery, store locators, ride-sharing, social check-ins — increasingly common features).

The core value is that MongoDB can store **geospatial data** (as GeoJSON) and run **geospatial queries** directly — finding documents by **proximity** (`$near` — "places near me", sorted by distance, the foundation of location-search features), **containment** (`$geoWithin` — documents inside an area or radius), and **intersection** (`$geoIntersects` — geometries overlapping a shape) — all made efficient by **2dsphere indexes** that account for the Earth's spherical geometry.

This means many location-based features can be built directly in MongoDB without a separate specialized geospatial database, simplifying the stack.

Understanding the practical essentials — GeoJSON storage (with the longitude-first coordinate order, a common gotcha), creating 2dsphere indexes, and the query operators ($near, $geoWithin, $geoIntersects) — enables implementing real location features.

Since location-based functionality is an increasingly common application need, and since MongoDB provides capable built-in geospatial support (storage, proximity/containment/intersection queries, efficient spherical indexing) that handles it directly, understanding MongoDB geospatial queries — GeoJSON storage, 2dsphere indexes, and the proximity/containment operators — is valuable, practically-relevant knowledge for building location-aware applications on MongoDB, a useful capability for the common "find things near a location" requirement.