minWordSizefor1Typo

Minimum number of characters in a query word before allowing one typo

The minWordSizefor1Typo parameter sets the minimum length a query word must have before Algolia allows one typo in that word. Query words shorter than this setting must match exactly.

Lowering this setting can lead to more matches, but might include more irrelevant results for short queries. To learn more, see Configure typo tolerance word size.

Examples

Set the default minimum character count to allow one typo

Current API clients

C#

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

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

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

UpdatedAtResponse response = client.setSettings("INDEX_NAME", new IndexSettings().setMinWordSizefor1Typo(4));

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

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(minWordSizefor1Typo = 4),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['minWordSizefor1Typo' => 4,
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "minWordSizefor1Typo": 4,
    },
)

response = client.set_settings("INDEX_NAME", Algolia::Search::IndexSettings.new(min_word_sizefor1_typo: 4))

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

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

Legacy API clients

C#

IndexSettings settings = new IndexSettings();
settings.MinWordSizefor1Typo = 4;

index.SetSettings(settings);

res, err := index.SetSettings(search.Settings{
	opt.MinWordSizefor1Typo(4),
})

index.setSettings(
  new IndexSettings().setMinWordSizefor1Typo(4)
);

index
  .setSettings({
    minWordSizefor1Typo: 4,
  })
  .then(() => {
    // done
  });

val settings = settings {
    minWordSizeFor1Typo = 4
}

index.setSettings(settings)

$index->setSettings([
  'minWordSizefor1Typo' => 4
]);

index.set_settings({"minWordSizefor1Typo": 4})

index.set_settings(
  {
    minWordSizefor1Typo: 4
  }
)

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

let settings = Settings()
  .set(\.minWordSizeFor1Typo, to: 4)

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

Override the default minimum character count to allow one typo for the current search

Current API clients

C#

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

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

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

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

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

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = SearchParamsObject(query = "query", minWordSizefor1Typo = 2),
  )

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

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

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

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

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

Legacy API clients

C#

index.Search(new Query("query")
{
    MinWordSizefor1Typo = 2
});

res, err := index.Search(
  "query",
  opt.MinWordSizefor1Typo(2),
})

index.search(
  new Query("query").setMinWordSizefor1Typo(2)
);

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

val query = query("query") {
    minWordSizeFor1Typo = 2
}

index.search(query)

$results = $index->search('query', [
  'minWordSizefor1Typo' => 2
]);

results = index.search("query", {"minWordSizefor1Typo": 2})

results = index.search(
  "query",
  {
    minWordSizefor1Typo: 2
  }
)

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

let query = Query("query")
  .set(\.minWordSizeFor1Typo, to: 2)

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