0Pricing
Elasticsearch & Full Text Search Systems · Lesson

Geospatial Search Capabilities

Implement geo-point and geo-shape mappings to perform location-based searches, proximity queries, and geospatial aggregations.

Geospatial Search Capabilities is a free Elasticsearch & Full Text Search Systems lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Elasticsearch & Full Text Search Systems learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Location-Aware Search

Welcome to Geospatial Search! Many modern applications rely on location data, from finding nearby restaurants to tracking delivery vehicles.

Elasticsearch provides powerful features to index, search, and analyze geographic information efficiently.

The `geo_point` Field

The most common way to store a single geographical location in Elasticsearch is using the geo_point data type.

It represents a specific point on Earth using its latitude and longitude coordinates.

  • Latitude: North-South position (e.g., 48.8584)
  • Longitude: East-West position (e.g., 2.2945)

Mapping `geo_point` Data

Before indexing documents with location data, you need to define a geo_point field in your index mapping. This tells Elasticsearch how to interpret the coordinates.

Try setting up an index named places with a location field of type geo_point:

curl -X PUT "localhost:9200/places?pretty" -H 'Content-Type: application/json' -d'
{
  "mappings": {
    "properties": {
      "location": {
        "type": "geo_point"
      },
      "name": {
        "type": "text"
      }
    }
  }
}'

Adding Geo-Tagged Documents

Now that our places index is mapped, we can index documents containing geo_point data. The location field can accept an object with lat and lon properties.

Index the Eiffel Tower's location:

curl -X PUT "localhost:9200/places/_doc/1?pretty" -H 'Content-Type: application/json' -d'
{
  "name": "Eiffel Tower",
  "location": {
    "lat": 48.8584,
    "lon": 2.2945
  }
}'

Searching by Distance: `geo_distance`

One of the most common geospatial queries is finding documents within a certain radius of a central point. This is achieved using the geo_distance query.

You specify a distance and the reference point, and Elasticsearch returns all matching documents.

`geo_distance` Query Example

Let's find all places within 5 kilometers of the Eiffel Tower's coordinates. This query is perfect for 'find restaurants near me' features.

Run this query:

curl -X GET "localhost:9200/places/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "geo_distance": {
      "distance": "5km",
      "location": {
        "lat": 48.8584,
        "lon": 2.2945
      }
    }
  }
}'

Bounding Box Search (`geo_bounding_box`)

Another useful query is geo_bounding_box, which allows you to find all documents whose geo_point falls within a specified rectangular area.

You define the box by providing its top_left and bottom_right coordinates.

`geo_bounding_box` Query Example

Imagine you have a map view and only want to show results within the current screen. A geo_bounding_box query is ideal for this scenario.

Here's an example searching within a small area around Paris:

curl -X GET "localhost:9200/places/_search?pretty" -H 'Content-Type: application/json' -d'
{
  "query": {
    "geo_bounding_box": {
      "location": {
        "top_left": {
          "lat": 49,
          "lon": 2
        },
        "bottom_right": {
          "lat": 48,
          "lon": 3
        }
      }
    }
  }
}'

Beyond Points: `geo_shape`

While geo_point is great for single locations, what if you need to represent complex geometries like a park boundary, a river, or a country's outline?

For this, Elasticsearch offers the geo_shape data type, which supports various GeoJSON shapes (polygons, lines, multi-points, etc.).

`geo_shape` Mapping & Indexing

To use geo_shape, you first map the field as geo_shape. Then, you can index documents with complex geometries, typically in GeoJSON format. Here's how to map and index a simple polygon representing a district:

curl -X PUT "localhost:9200/regions?pretty" -H 'Content-Type: application/json' -d'
{
  "mappings": {
    "properties": {
      "area": {
        "type": "geo_shape"
      },
      "name": {
        "type": "keyword"
      }
    }
  }
}'

curl -X PUT "localhost:9200/regions/_doc/1?pretty" -H 'Content-Type: application/json' -d'
{
  "name": "Paris District",
  "area": {
    "type": "polygon",
    "coordinates": [
      [
        [2.2, 48.8],
        [2.3, 48.8],
        [2.3, 48.9],
        [2.2, 48.9],
        [2.2, 48.8]
      ]
    ]
  }
}'

Geo Query Challenge

You want to find all restaurants located within the boundaries of a specific park. The park's boundaries are complex and not a simple rectangle.

Geospatial Search Recap

You've explored Elasticsearch's powerful geospatial capabilities!

  • We learned about the geo_point type for single locations (latitude, longitude).
  • We used geo_distance for proximity searches and geo_bounding_box for rectangular area searches.
  • We also introduced the advanced geo_shape type for complex geometries like polygons.

These tools are essential for building sophisticated location-aware applications.

Frequently asked questions

Is the “Geospatial Search Capabilities” lesson free?

Yes — the full text of “Geospatial Search Capabilities” is free to read here on the web, and the Elasticsearch & Full Text Search Systems course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Elasticsearch & Full Text Search Systems course, upgrade to CoddyKit PRO.

What will I learn in “Geospatial Search Capabilities”?

Implement geo-point and geo-shape mappings to perform location-based searches, proximity queries, and geospatial aggregations. You practise Elasticsearch & Full Text Search Systems with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Elasticsearch & Full Text Search Systems?

No prior experience is required. Elasticsearch & Full Text Search Systems on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Geospatial Search Capabilities” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Elasticsearch & Full Text Search Systems lesson?

Yes. Every Elasticsearch & Full Text Search Systems lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Geospatial Search Capabilities
  2. Time-Series Data Management
  3. Production Deployment Strategies
  4. Index Lifecycle Management
← Back to Elasticsearch & Full Text Search Systems