Skip to main content
The minWordSizefor2Typos parameter sets the minimum length a query word must have before Algolia allows two typos in that word. Query words shorter than this setting can only have up to one typo. 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 two typos

Current API clients

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

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

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

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

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

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

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

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

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

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

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

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

index.SetSettings(settings);

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

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

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

val settings = settings {
    minWordSizeFor2Typos = 4
}

index.setSettings(settings)

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

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

index.set_settings(
  {
    minWordSizefor2Typos: 4
  }
)

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

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

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

Current API clients

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

index.search(query)

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

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

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

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

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

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}
Last modified on May 19, 2026