sortFacetValuesBy

Controls how facet values are sorted

The sortFacetValuesBy parameter controls the order in which facet values are returned for each facet in the response.
This affects data returned by the facets parameter, but not how values are displayed in the UI.

To customize display order, see Facet value display.

Options

count

Sort facet values by descending count (most frequent values first). The count is the number of records matching the query with that facet value. This is the default.

alpha

Sort facet values alphabetically, from A to Z.

Usage

To control how many facet values are returned, see maxValuesPerFacet.

Examples

Set default sort order for facet values

Current API clients

C#

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings { SortFacetValuesBy = "alpha" }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    sortFacetValuesBy: "alpha",
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetSortFacetValuesBy("alpha")))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings("INDEX_NAME", new IndexSettings().setSortFacetValuesBy("alpha"));

const response = await client.setSettings({
  indexName: 'theIndexName',
  indexSettings: { sortFacetValuesBy: 'alpha' },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(sortFacetValuesBy = "alpha"),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['sortFacetValuesBy' => 'alpha',
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "sortFacetValuesBy": "alpha",
    },
)

response = client.set_settings("INDEX_NAME", Algolia::Search::IndexSettings.new(sort_facet_values_by: "alpha"))

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      sortFacetValuesBy = Some("alpha")
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(sortFacetValuesBy: "alpha")
)

Legacy API clients

C#

IndexSettings settings = new IndexSettings();
settings.SortFacetValuesBy = "alpha";

index.SetSettings(settings);

res, err := index.SetSettings(search.Settings{
	SortFacetValuesBy: opt.SortFacetValuesBy("alpha"),
})

index.setSettings(
  new IndexSettings().setSortFacetValuesBy("alpha")
);

index
  .setSettings({
    sortFacetValuesBy: "alpha",
  })
  .then(() => {
    // done
  });

val settings = settings {
    sortFacetsBy = SortFacetsBy.Alpha
}

index.setSettings(settings)

$index->setSettings([
  'sortFacetValuesBy': 'alpha'
]);

index.set_settings({"sortFacetValuesBy": "alpha"})

index.set_settings(
  {
    sortFacetValuesBy: "alpha"
  }
)

client.execute {
  setSettings of "myIndex" `with` IndexSettings(
    sortFacetValuesBy = Some("alpha")
  )
}

let settings = Settings()
  .set(\.sortFacetsBy, to: .alpha)

index.setSettings(settings) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

Change sort order for facet values at query time

Current API clients

C#

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(new SearchParamsObject { Query = "query", SortFacetValuesBy = "count" })
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    sortFacetValuesBy: "count",
  ),
);

response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
  "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
  search.NewEmptySearchParamsObject().SetQuery("query").SetSortFacetValuesBy("count"))))
if err != nil {
  // handle the eventual error
  panic(err)
}

SearchResponse response = client.searchSingleIndex(
  "INDEX_NAME",
  new SearchParamsObject().setQuery("query").setSortFacetValuesBy("count"),
  Hit.class
);

const response = await client.searchSingleIndex({
  indexName: 'indexName',
  searchParams: { query: 'query', sortFacetValuesBy: 'count' },
});

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = SearchParamsObject(query = "query", sortFacetValuesBy = "count"),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'sortFacetValuesBy' => 'count',
    ],
);

response = client.search_single_index(
    index_name="INDEX_NAME",
    search_params={
        "query": "query",
        "sortFacetValuesBy": "count",
    },
)

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(query: "query", sort_facet_values_by: "count")
)

val response = Await.result(
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = Some(
      SearchParamsObject(
        query = Some("query"),
        sortFacetValuesBy = Some("count")
      )
    )
  ),
  Duration(100, "sec")
)

let response: SearchResponse<Hit> = try await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
        query: "query",
        sortFacetValuesBy: "count"
    ))
)

Legacy API clients

C#

index.Search(new Query("query")
{
    SortFacetValuesBy = "count"
});

res, err := index.Search(
  "query",
  opt.SortFacetValuesBy("count"),
})

index.search(
  new Query("query").setSortFacetValuesBy("count")
);

index
  .search("query", {
    sortFacetValuesBy: "count",
  })
  .then(({ hits }) => {
    console.log(hits);
  });

val query = query("query") {
    sortFacetsBy = SortFacetsBy.Count
}

index.search(query)

$results = $index->search('query', [
  'sortFacetValuesBy' => "count"
]);

results = index.search("query", {"sortFacetValuesBy": "count"})

results = index.search(
  "query",
  {
    sortFacetValuesBy: "count"
  }
)

client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    sortFacetValuesBy = Some("count")
  )
}

let query = Query("query")
  .set(\.sortFacetsBy, to: .count)

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}