Filter Results Around a Location

1
2
3
4
require 'algolia'

client = Algolia::Search::Client.create('AJ0P3S7DWQ', '••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb')
index = client.init_index('your_index_name')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// for the default version
const algoliasearch = require('algoliasearch');

// for the default version
import algoliasearch from 'algoliasearch';

// for the search only version
import algoliasearch from 'algoliasearch/lite';

// or just use algoliasearch if you are using a <script> tag
// if you are using AMD module loader, algoliasearch will not be defined in window,
// but in the AMD modules of the page

const client = algoliasearch('AJ0P3S7DWQ', '••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb');
const index = client.initIndex('your_index_name');

1
2
3
4
from algoliasearch.search_client import SearchClient

client = SearchClient.create('AJ0P3S7DWQ', '••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb')
index = client.init_index('your_index_name')

1
2
let client = SearchClient(appID: "AJ0P3S7DWQ", apiKey: "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb")
let index = client.index(withName: "your_index_name")

1
2
SearchClient client = new SearchClient("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb");
SearchIndex index = client.InitIndex("your_index_name");

1
2
3
4
SearchClient client =
DefaultSearchClient.create("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb");

SearchIndex index = client.initIndex("your_index_name");

1
2
3
4
5
6
7
8
package main

import "github.com/algolia/algoliasearch-client-go/v3/algolia/search"

func main() {
  client := search.NewClient("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb")
  index := client.InitIndex("your_index_name")
}

1
2
// No initIndex
val client = new AlgoliaClient("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb")

1
2
3
4
5
6
7
val client = ClientSearch(
    applicationID = ApplicationID("AJ0P3S7DWQ"),
    apiKey = APIKey("••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb")
)
val indexName = IndexName("your_index_name")

client.initIndex(indexName)

1
2
3
4
5
6
7
8
9
10
11
index.set_settings(
  searchableAttributes: [
    'name',
    'city',
    'country',
    'iata_code'
  ],
  customRanking: [
    'desc(links_count)'
  ]
)

1
2
3
4
5
6
7
8
9
10
11
index.setSettings({
  searchableAttributes: [
    'name',
    'city',
    'country',
    'iata_code'
  ],
  customRanking: ['desc(links_count)'],
}).then(() => {
  // done
});

1
2
3
4
5
6
7
8
9
10
11
index.set_settings(
  searchableAttributes: [
    'name',
    'city',
    'country',
    'iata_code'
  ],
  customRanking: [
    'desc(links_count)'
  ]
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
let settings = [
  "searchableAttributes": [
    "name",
    "city",
    "country",
    "iata_code"
  ],
  "customRanking": [
    "desc(links_count)"
  ]
]
index.setSettings(
  settings,
  completionHandler: { (content, error) -> Void in
    // [...]
  }
)

1
2
3
4
5
6
7
8
9
10
IndexSettings settings = new IndexSettings
{
  SearchableAttributes = new List<string> { "name", "city", "country", "iata_code" },
  CustomRanking = new List<string> { "desc(links_count)" }
};

index.SetSettings(setting);

// Asynchronous
await index.SetSettingsAsync(settings);

1
2
3
4
index.setSettings(new IndexSettings()
        .setSearchableAttributes(Arrays.asList("name", "city", "country", "iata_code"))
        .setCustomRanking(Collections.singletonList("desc(links_count"))
);

1
2
3
4
5
6
7
8
9
res, err := index.SetSettings(search.Settings{
  SearchableAttributes: opt.SearchableAttributes(
    "name",
    "city",
    "country",
    "iata_code",
  ),
  CustomRanking: opt.CustomRanking("desc(links_count)"),
})

1
2
3
4
5
6
7
8
9
10
11
12
13
val result: Future[Task] = client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    searchableAttributes = Some(Seq(
      SearchableAttributes.attributes("name")
      SearchableAttributes.attribute("city")
      SearchableAttributes.unordered("country")
      SearchableAttributes.attribute("iata_code")
    ))
    customRanking = Some(Seq(
      CustomRanking.desc("links_count")
    ))
  )
}

1
2
3
4
5
6
7
8
9
10
11
12
13
val settings = settings {
    searchableAttributes {
        +"name"
        +"city"
        +"country"
        +"iata_code"
    }
    customRanking {
        +Desc("links_count")
    }
}

index.setSettings(settings)

1
results = index.search('', { aroundLatLng: '40.71, -74.01' })

1
2
3
4
5
index.search('', {
  aroundLatLng: '40.71, -74.01'
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
results = index.search('', {
    'aroundLatLng': '40.71, -74.01'
})

1
2
3
4
5
6
let query = Query(query: "")
query.aroundLatLng = LatLng(lat: 40.71, lng: -74.01)

index.search(query, completionHandler: { (res, error) in
  print(res)
})

1
2
3
4
index.Search<T>(new Query("")
{
    AroundLatLng = new List<string> { "40.71, -74.01" }
});

1
index.search(new Query().setAroundLatLng("40.71, -74.01"));

1
res, err := index.Search("", opt.AroundLatLng("40.71, -74.01"))

1
2
3
4
5
6
7
8
client.execute {
  search into "myIndex" query Query(
    query = Some(""),
    aroundLatLng = Some(
      AroundLatLng("40.71, -74.01")
    )
  )
}

1
2
3
4
5
val query = query {
    aroundLatLng = Point(40.71f, -74.01f)
}

index.search(query)

1
2
3
4
5
6
7
8
results = index.search('', {
  aroundLatLngViaIP: true,
  headers: {
    # '94.228.178.246' should be replaced with the actual IP you would like to search around.
    # Depending on your stack there are multiple ways to get this information.
    'X-Forwarded-For': '94.228.178.246'
  }
})

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * '94.228.178.246' should be replaced with the actual IP you would like to search around.
 * Depending on your stack there are multiple ways to get this information.
 */

index.search('', {
  aroundLatLngViaIP: true,
  headers: {
    'X-Forwarded-For': '94.228.178.246'
  }
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
6
7
8
9
# '94.228.178.246' should be replaced with the actual IP you would like to search around.
# Depending on your stack there are multiple ways to get this information.

ip = '94.228.178.246'

results = index.search('', {
    'aroundLatLngViaIP': True,
    'X-Forwarded-For': ip
})

1
2
3
4
5
6
7
8
9
10
11
/// '94.228.178.246' should be replaced with the actual IP you would like to search around.
/// Depending on your stack there are multiple ways to get this information.

client.setHeader(withName: "X-Forwarded-For", to: "94.228.178.246")

let query = Query()
query.aroundLatLngViaIP = true

index.search(query, completionHandler: { (res, error) in
  print(res)
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// '94.228.178.246' should be replaced with the actual IP you would like to search around.
// Depending on your stack there are multiple ways to get this information.

var configuration = new SearchConfig("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb")
{
    DefaultHeaders = new Dictionary<string, string> { { "X-Forwarded-For", "94.228.178.246" } }
};

SearchClient client = new SearchClient(configuration);

index.Search<T>(new Query("")
{
    AroundLatLngViaIP = true
});

1
2
3
4
5
6
7
8
9
// '94.228.178.246' should be replaced with the actual IP you would like to search around.
// Depending on your stack there are multiple ways to get this information.

index.search(
  new Query()
    .setAroundLatLngViaIP(true),
  new RequestOptions()
    .addExtraHeader("X-Forwarded-For", "94.228.178.246")
);

1
2
3
4
5
6
7
8
// "94.228.178.246" should be replaced with the actual IP you would like to search around.
// Depending on your stack there are multiple ways to get this information.

extraHeaders := opt.ExtraHeaders(map[string]string{
	"X-Forwarded-For": "94.228.178.246",
})

res, err := index.Search("", opt.AroundLatLngViaIP(true), extraHeaders)

1
2
3
4
5
6
7
8
9
10
11
// '94.228.178.246' should be replaced with the actual IP you would like to search around.
// Depending on your stack there are multiple ways to get this information.

client.execute {
  search into "myIndex" query Query(
    query = Some(""),
    aroundLatLngViaIP = Some(true)
  ) options RequestsOptions(
    extraHeaders = Some(Map("X-Forwarded-For" -> "94.228.178.246"))
  )
}

1
2
3
4
5
6
7
8
9
10
/**
 * '94.228.178.246' should be replaced with the actual IP you would like to search around.
 * Depending on your stack there are multiple ways to get this information.
 */

val query = query {
    aroundLatLngViaIP = true
}

index.search(query, requestOptions { headerForwardedFor("94.228.178.246") })

1
2
3
4
results = index.search('', {
  aroundLatLng: '40.71, -74.01',
  aroundRadius: 1000000 # 1000 km
})

1
2
3
4
5
6
index.search('', {
  aroundLatLng: '40.71, -74.01',
  aroundRadius: 1000000 // 1000 km
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
results = index.search('', {
    'aroundLatLng': '40.71, -74.01'
    'aroundRadius' => 1000000 # 1000 km
})

1
2
3
4
5
6
7
let query = Query(query: "")
query.aroundLatLng = LatLng(lat: 40.71, lng: -74.01)
query.aroundRadius = .explicit(1000000) // 1000 km

index.search(query, completionHandler: { (res, error) in
  print(res)
})

1
2
3
4
5
index.Search<T>(new Query("")
{
    AroundLatLng = new List<string> { "40.71, -74.01" },
    AroundRadius = 1000000 // 1000 km
});

1
2
3
4
index.search(new Query()
      .setAroundLatLng("40.71, -74.01")
      .setAroundRadius(AroundRadius.of(1000000)) // 1000 km
);

1
2
3
4
5
res, err := index.Search(
  "",
  opt.AroundLatLng("40.71, -74.01"),
  opt.AroundRadius(1000000), // 1000 km
)

1
2
3
4
5
6
7
8
9
10
11
client.execute {
  search into "myIndex" query Query(
    query = Some(""),
    aroundLatLng = Some(
      AroundLatLng("40.71, -74.01")
    ),
    aroundRadius = Some(
      AroundRadius.integer(1000000)
    ) // 1000 km
  )
}

1
2
3
4
5
6
val query = query {
    aroundLatLng = Point(40.71f, -74.01f)
    aroundRadius = AroundRadius.InMeters(1000000) // 10000 km
}

index.search(query)