> ## Documentation Index
> Fetch the complete documentation index at: https://algolia.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Filter results inside a polygon

> Use Algolia's geographical search capabilities to filter results inside a polygon.

export const Index = () => <Tooltip tip="An Algolia index is a searchable dataset that consists of records and configuration settings. These settings define how the records are searched and ranked.">
    index
  </Tooltip>;

In this tutorial, you'll learn how to filter results around a polygonal location.
This location can either be set manually or taken from the current user position.

To run the code examples on this page, [install the latest API client](/doc/libraries/sdk/install).

## Dataset

The guide uses a dataset of the 3,000+ biggest airports in the world.

```json JSON icon="braces" theme={"system"}
[
 {
    "objectID": "3797",
    "name": "John F Kennedy Intl",
    "city": "New York",
    "country": "United States",
    "iata_code": "JFK",
    "_geoloc": {
      "lat": 40.639751,
      "lng": -73.778925
    },
    "links_count": 911
  }
]
```

To tell Algolia where each record is located,
the latitude and longitude must be stored in the `_geoloc` attribute.

## Initialize the client

1. [Download the data set](https://github.com/algolia/datasets/blob/master/airports/airports.json)
2. [Set up an API client and send your data to Algolia](/doc/guides/sending-and-managing-data/send-and-update-your-data/how-to/importing-with-the-api)

## Configure index settings

Even if you just want to sort by distance to a location, your textual relevance should also be good so that users can refine the search with a query.
To do that, you must configure the <Index />.

The searchable attributes are: `name`, `city`, `country`, and `iata_code`.

<CodeGroup>
  ```cs C# theme={"system"}
  var response = await client.SetSettingsAsync(
    "INDEX_NAME",
    new IndexSettings
    {
      SearchableAttributes = new List<string> { "name", "country", "city", "iata_code" },
      CustomRanking = new List<string> { "desc(links_count)" },
    }
  );
  ```

  ```dart Dart theme={"system"}
  final response = await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(
      searchableAttributes: [
        "name",
        "country",
        "city",
        "iata_code",
      ],
      customRanking: [
        "desc(links_count)",
      ],
    ),
  );
  ```

  ```go Go theme={"system"}
  response, err := client.SetSettings(client.NewApiSetSettingsRequest(
    "INDEX_NAME",
    search.NewEmptyIndexSettings().SetSearchableAttributes(
      []string{"name", "country", "city", "iata_code"}).SetCustomRanking(
      []string{"desc(links_count)"})))
  if err != nil {
    // handle the eventual error
    panic(err)
  }
  ```

  ```java Java theme={"system"}
  UpdatedAtResponse response = client.setSettings(
    "INDEX_NAME",
    new IndexSettings()
      .setSearchableAttributes(Arrays.asList("name", "country", "city", "iata_code"))
      .setCustomRanking(Arrays.asList("desc(links_count)"))
  );
  ```

  ```js JavaScript theme={"system"}
  const response = await client.setSettings({
    indexName: 'theIndexName',
    indexSettings: {
      searchableAttributes: ['name', 'country', 'city', 'iata_code'],
      customRanking: ['desc(links_count)'],
    },
  });
  ```

  ```kotlin Kotlin theme={"system"}
  var response =
    client.setSettings(
      indexName = "INDEX_NAME",
      indexSettings =
        IndexSettings(
          searchableAttributes = listOf("name", "country", "city", "iata_code"),
          customRanking = listOf("desc(links_count)"),
        ),
    )
  ```

  ```php PHP theme={"system"}
  $response = $client->setSettings(
      'INDEX_NAME',
      ['searchableAttributes' => [
          'name',

          'country',

          'city',

          'iata_code',
      ],
          'customRanking' => [
              'desc(links_count)',
          ],
      ],
  );
  ```

  ```python Python theme={"system"}
  response = client.set_settings(
      index_name="INDEX_NAME",
      index_settings={
          "searchableAttributes": [
              "name",
              "country",
              "city",
              "iata_code",
          ],
          "customRanking": [
              "desc(links_count)",
          ],
      },
  )
  ```

  ```ruby Ruby theme={"system"}
  response = client.set_settings(
    "INDEX_NAME",
    Algolia::Search::IndexSettings.new(
      searchable_attributes: ["name", "country", "city", "iata_code"],
      custom_ranking: ["desc(links_count)"]
    )
  )
  ```

  ```scala Scala theme={"system"}
  val response = Await.result(
    client.setSettings(
      indexName = "INDEX_NAME",
      indexSettings = IndexSettings(
        searchableAttributes = Some(Seq("name", "country", "city", "iata_code")),
        customRanking = Some(Seq("desc(links_count)"))
      )
    ),
    Duration(100, "sec")
  )
  ```

  ```swift Swift theme={"system"}
  let response = try await client.setSettings(
      indexName: "INDEX_NAME",
      indexSettings: IndexSettings(
          searchableAttributes: ["name", "country", "city", "iata_code"],
          customRanking: ["desc(links_count)"]
      )
  )
  ```
</CodeGroup>

## Filtering inside a polygonal area

The USA can be considered as a polygon:

<img src="https://mintcdn.com/algolia/AACpGv43fS_1tsyy/images/guides/geo-search/filter-inside-polygon.png?fit=max&auto=format&n=AACpGv43fS_1tsyy&q=85&s=737da5678fcd7b4a948c1b0fc1a8ee52" alt="Screenshot of a map showing the United States with a polygonal filter drawn over it, highlighting a specific region." width="471" height="341" data-path="images/guides/geo-search/filter-inside-polygon.png" />

To filter inside this rectangle, you need to pass the latitude and longitude of all the points to the `insidePolygon` parameter:

* 42.01,-124.31,
* 48.835509470063045,-124.40453125000005
* 45.01082951668149,-65.95726562500005
* 31.247243545293433,-81.06578125000004
* 25.924152577235226,-97.68234374999997
* 32.300311895879545,-117.54828125

The empty query (`''`) returns all matching airports.

<CodeGroup>
  ```cs C# theme={"system"}
  var response = await client.SearchSingleIndexAsync<Hit>(
    "INDEX_NAME",
    new SearchParams(
      new SearchParamsObject
      {
        InsidePolygon = new List<List<Double>>
        {
          new List<Double>
          {
            42.01,
            -124.31,
            48.835509470063045,
            -124.40453125000005,
            45.01082951668149,
            -65.95726562500005,
            31.247243545293433,
            -81.06578125000004,
            25.924152577235226,
            -97.68234374999997,
            32.300311895879545,
            -117.54828125,
          },
        },
      }
    )
  );
  ```

  ```dart Dart theme={"system"}
  final response = await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchParamsObject(
      insidePolygon: [
        [
          42.01,
          -124.31,
          48.835509470063045,
          -124.40453125000005,
          45.01082951668149,
          -65.95726562500005,
          31.247243545293433,
          -81.06578125000004,
          25.924152577235226,
          -97.68234374999997,
          32.300311895879545,
          -117.54828125,
        ],
      ],
    ),
  );
  ```

  ```go Go theme={"system"}
  response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
    "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
    search.NewEmptySearchParamsObject().SetInsidePolygon(
      [][]float64{
        {
          42.01,
          -124.31,
          48.835509470063045,
          -124.40453125000005,
          45.01082951668149,
          -65.95726562500005,
          31.247243545293433,
          -81.06578125000004,
          25.924152577235226,
          -97.68234374999997,
          32.300311895879545,
          -117.54828125,
        },
      }))))
  if err != nil {
    // handle the eventual error
    panic(err)
  }
  ```

  ```java Java theme={"system"}
  SearchResponse response = client.searchSingleIndex(
    "INDEX_NAME",
    new SearchParamsObject().setInsidePolygon(
      Arrays.asList(
        Arrays.asList(
          42.01,
          -124.31,
          48.835509470063045,
          -124.40453125000005,
          45.01082951668149,
          -65.95726562500005,
          31.247243545293433,
          -81.06578125000004,
          25.924152577235226,
          -97.68234374999997,
          32.300311895879545,
          -117.54828125
        )
      )
    ),
    Hit.class
  );
  ```

  ```js JavaScript theme={"system"}
  const response = await client.searchSingleIndex({
    indexName: 'indexName',
    searchParams: {
      insidePolygon: [
        [
          42.01, -124.31, 48.835509470063045, -124.40453125000005, 45.01082951668149, -65.95726562500005,
          31.247243545293433, -81.06578125000004, 25.924152577235226, -97.68234374999997, 32.300311895879545,
          -117.54828125,
        ],
      ],
    },
  });
  ```

  ```kotlin Kotlin theme={"system"}
  var response =
    client.searchSingleIndex(
      indexName = "INDEX_NAME",
      searchParams =
        SearchParamsObject(
          insidePolygon =
            listOf(
              listOf(
                42.01,
                -124.31,
                48.835509470063045,
                -124.40453125000005,
                45.01082951668149,
                -65.95726562500005,
                31.247243545293433,
                -81.06578125000004,
                25.924152577235226,
                -97.68234374999997,
                32.300311895879545,
                -117.54828125,
              )
            )
        ),
    )
  ```

  ```php PHP theme={"system"}
  $response = $client->searchSingleIndex(
      'INDEX_NAME',
      ['insidePolygon' => [
          [
              42.01,

              -124.31,

              48.835509470063045,

              -124.40453125000005,

              45.01082951668149,

              -65.95726562500005,

              31.247243545293433,

              -81.06578125000004,

              25.924152577235226,

              -97.68234374999997,

              32.300311895879545,

              -117.54828125,
          ],
      ],
      ],
  );
  ```

  ```python Python theme={"system"}
  response = client.search_single_index(
      index_name="INDEX_NAME",
      search_params={
          "insidePolygon": [
              [
                  42.01,
                  -124.31,
                  48.835509470063045,
                  -124.40453125000005,
                  45.01082951668149,
                  -65.95726562500005,
                  31.247243545293433,
                  -81.06578125000004,
                  25.924152577235226,
                  -97.68234374999997,
                  32.300311895879545,
                  -117.54828125,
              ],
          ],
      },
  )
  ```

  ```ruby Ruby theme={"system"}
  response = client.search_single_index(
    "INDEX_NAME",
    Algolia::Search::SearchParamsObject.new(
      inside_polygon: [
        [
          42.01,
          -124.31,
          48.835509470063045,
          -124.40453125000005,
          45.01082951668149,
          -65.95726562500005,
          31.247243545293433,
          -81.06578125000004,
          25.924152577235226,
          -97.68234374999997,
          32.300311895879545,
          -117.54828125
        ]
      ]
    )
  )
  ```

  ```scala Scala theme={"system"}
  val response = Await.result(
    client.searchSingleIndex(
      indexName = "INDEX_NAME",
      searchParams = Some(
        SearchParamsObject(
          insidePolygon = Some(
            Seq(
              Seq(42.01, -124.31, 48.835509470063045, -124.40453125000005, 45.01082951668149, -65.95726562500005,
                31.247243545293433, -81.06578125000004, 25.924152577235226, -97.68234374999997, 32.300311895879545,
                -117.54828125)
            )
          )
        )
      )
    ),
    Duration(100, "sec")
  )
  ```

  ```swift Swift theme={"system"}
  let response: SearchResponse<Hit> = try await client.searchSingleIndex(
      indexName: "INDEX_NAME",
      searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(insidePolygon: [[
          42.01,
          -124.31,
          48.835509470063045,
          -124.40453125000005,
          45.01082951668149,
          -65.95726562500005,
          31.247243545293433,
          -81.06578125000004,
          25.924152577235226,
          -97.68234374999997,
          32.300311895879545,
          -117.54828125,
      ]]))
  )
  ```
</CodeGroup>