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

# relevancyStrictness

> Threshold for including results in relevant sorts

export const Setting = ({type, default: defaultValue, defaultNote, scope, min, max, formerly}) => {
  const renderedDefault = defaultValue === '' ? '""' : defaultValue;
  const renderedNote = defaultNote ? `(${defaultNote})` : '';
  return <ul>
      <li><strong>Type:</strong> <code>{type}</code></li>
      <li><strong>Default:</strong> <code>{renderedDefault}</code>{renderedNote}</li>
      {min && <li><strong>Min:</strong> <code>{min}</code></li>}
      {max && <li><strong>Max:</strong> <code>{max}</code></li>}
      <li><strong>Scope:</strong> <a href="/doc/api-reference/api-parameters"><code>{scope}</code></a></li>
      {formerly && <li>
          <strong>Deprecated name:</strong> <code>{formerly}</code>
        </li>}
    </ul>;
};

<Setting type="list<int>" default="100" scope="settings,search" />

## Options

<ParamField path="100">
  Default value. Returns and sorts only the top relevant results.
</ParamField>

<ParamField path="90">
  Includes records with at least 90% similarity to the most relevant result.
</ParamField>

<ParamField path="0">
  Returns up to `paginationLimitedTo` results (if there's no timeout),
  sorted using the `customRanking` of your relevant sort.
</ParamField>

## Usage

* Only available on applications with the [Relevant sort](/doc/guides/managing-results/refine-results/sorting/in-depth/relevant-sort) feature enabled.
* Can only be set on [virtual replicas](/doc/guides/managing-results/refine-results/sorting/in-depth/replicas#standard-and-virtual-replicas).
* Accepts integer values from 0 to 100 (inclusive).
* Lower values include more results but may reduce precision.
* You can test values manually or through an [A/B test](/doc/guides/ab-testing/what-is-ab-testing) to find the optimal balance between result relevancy and recall.

## Examples

### Set the default relevancy strictness for an index with Relevant sort

<AccordionGroup>
  <Accordion title="Current API clients" defaultOpen="true">
    <CodeGroup>
      ```cs C# theme={"system"}
      var response = await client.SetSettingsAsync(
        "INDEX_NAME",
        new IndexSettings
        {
          CustomRanking = new List<string> { "asc(textual_attribute)" },
          RelevancyStrictness = 0,
        }
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.setSettings(
        indexName: "INDEX_NAME",
        indexSettings: IndexSettings(
          customRanking: [
            "asc(textual_attribute)",
          ],
          relevancyStrictness: 0,
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SetSettings(client.NewApiSetSettingsRequest(
        "INDEX_NAME",
        search.NewEmptyIndexSettings().SetCustomRanking(
          []string{"asc(textual_attribute)"}).SetRelevancyStrictness(0)))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      UpdatedAtResponse response = client.setSettings(
        "INDEX_NAME",
        new IndexSettings().setCustomRanking(Arrays.asList("asc(textual_attribute)")).setRelevancyStrictness(0)
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.setSettings({
        indexName: 'theIndexName',
        indexSettings: { customRanking: ['asc(textual_attribute)'], relevancyStrictness: 0 },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings =
            IndexSettings(customRanking = listOf("asc(textual_attribute)"), relevancyStrictness = 0),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->setSettings(
          'INDEX_NAME',
          ['customRanking' => [
              'asc(textual_attribute)',
          ],
              'relevancyStrictness' => 0,
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.set_settings(
          index_name="INDEX_NAME",
          index_settings={
              "customRanking": [
                  "asc(textual_attribute)",
              ],
              "relevancyStrictness": 0,
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.set_settings(
        "INDEX_NAME",
        Algolia::Search::IndexSettings.new(custom_ranking: ["asc(textual_attribute)"], relevancy_strictness: 0)
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings = IndexSettings(
            customRanking = Some(Seq("asc(textual_attribute)")),
            relevancyStrictness = Some(0)
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response = try await client.setSettings(
          indexName: "INDEX_NAME",
          indexSettings: IndexSettings(customRanking: ["asc(textual_attribute)"], relevancyStrictness: 0)
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      var settings = new IndexSettings();
      settings.RelevancyStrictness = 90;
      ```

      ```go Go theme={"system"}
      res, err := index.SetSettings(search.Settings{
      	RelevancyStrictness: opt.RelevancyStrictness(90),
      })
      ```

      ```java Java theme={"system"}
      index.setSettings(
        new IndexSettings().setRelevancyStrictness(90)
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .setSettings({
          relevancyStrictness: 90,
        })
        .then(() => {
          // done
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val settings = settings {
          relevancyStrictness = 90
      }

      index.setSettings(settings)
      ```

      ```php PHP theme={"system"}
      $index->setSettings([
        'relevancyStrictness' => 90
      ]);
      ```

      ```python Python theme={"system"}
      index.set_settings({"relevancyStrictness": 90})
      ```

      ```ruby Ruby theme={"system"}
      index.set_settings(
        {
          relevancyStrictness: 90
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        setSettings of "myIndex" `with` IndexSettings(
          relevancyStrictness = Some(90)
        )
      }
      ```

      ```swift Swift theme={"system"}
      let settings = Settings()
        .set(\.RelevancyStrictness, to: 90)

      index.setSettings(settings) { result in
        if case .success(let response) = result {
          print("Response: \(response)")
        }
      }
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>

### Override the default relevancy strictness for the current search

<AccordionGroup>
  <Accordion title="Current API clients" defaultOpen>
    <CodeGroup>
      ```cs C# theme={"system"}
      var response = await client.SearchSingleIndexAsync<Hit>(
        "INDEX_NAME",
        new SearchParams(new SearchParamsObject { Query = "query", RelevancyStrictness = 70 })
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          relevancyStrictness: 70,
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetRelevancyStrictness(70))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject().setQuery("query").setRelevancyStrictness(70),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', relevancyStrictness: 70 },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = SearchParamsObject(query = "query", relevancyStrictness = 70),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'relevancyStrictness' => 70,
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "relevancyStrictness": 70,
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", relevancy_strictness: 70)
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              relevancyStrictness = Some(70)
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              relevancyStrictness: 70
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          RelevancyStrictness = 70
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.RelevancyStrictness(70),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("").setRelevancyStrictness(70)
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          relevancyStrictness: 70,
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val query = query("query") {
          relevancyStrictness = 70
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $results = $index->search('query', [
        'relevancyStrictness' => 70
      ]);
      ```

      ```python Python theme={"system"}
      results = index.search("query", {"relevancyStrictness": 70})
      ```

      ```ruby Ruby theme={"system"}
      results = index.search(
        "query",
        {
          relevancyStrictness: 70
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          relevancyStrictness = Some(70)
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.RelevancyStrictness, to: 70)

      index.search(query: query) { result in
        if case .success(let response) = result {
          print("Response: \(response)")
        }
      }
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>