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

# removeWordsIfNoResults

> Strategy for removing query words when there are no results

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="enum<string>" default="none" scope="settings,search" />

The `removeWordsIfNoResults` parameter Lets Algolia automatically remove one or more words from the query
and retry the search if no results are returned.

The goal is to avoid empty results by progressively simplifying the query until results are found.
Use `removeWordsIfNoResults` to configure this behavior.
For more information,
see [Remove words to improve results](/doc/guides/managing-results/optimize-search-results/empty-or-insufficient-results/in-depth/why-use-remove-words-if-no-results).

## Options

<ParamField path="none">
  Doesn't remove any words from the query.
  If no results are found,
  an empty result set is returned.
  (Default behavior.)
</ParamField>

<ParamField path="lastWords">
  Remove words from the **end** of the query one at a time,
  until results are found or a maximum of five words have been removed.
</ParamField>

<ParamField path="firstWords">
  Remove words from the **beginning** of the query one at a time,
  until results are found or a maximum of five words have been removed.
</ParamField>

<ParamField path="allOptional">
  Results can match any subset of the words,
  rather than requiring all of them.
</ParamField>

## Example

<AccordionGroup>
  <Accordion title="Current API clients" defaultOpen="true">
    <CodeGroup>
      ```cs C# theme={"system"}
      var response = await client.SetSettingsAsync(
        "INDEX_NAME",
        new IndexSettings { RemoveWordsIfNoResults = Enum.Parse<RemoveWordsIfNoResults>("None") }
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.setSettings(
        indexName: "INDEX_NAME",
        indexSettings: IndexSettings(
          removeWordsIfNoResults: RemoveWordsIfNoResults.fromJson("none"),
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SetSettings(client.NewApiSetSettingsRequest(
        "INDEX_NAME",
        search.NewEmptyIndexSettings().SetRemoveWordsIfNoResults(search.RemoveWordsIfNoResults("none"))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      UpdatedAtResponse response = client.setSettings(
        "INDEX_NAME",
        new IndexSettings().setRemoveWordsIfNoResults(RemoveWordsIfNoResults.NONE)
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.setSettings({
        indexName: 'theIndexName',
        indexSettings: { removeWordsIfNoResults: 'none' },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings =
            IndexSettings(
              removeWordsIfNoResults = RemoveWordsIfNoResults.entries.first { it.value == "none" }
            ),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->setSettings(
          'INDEX_NAME',
          ['removeWordsIfNoResults' => 'none',
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.set_settings(
          index_name="INDEX_NAME",
          index_settings={
              "removeWordsIfNoResults": "none",
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.set_settings(
        "INDEX_NAME",
        Algolia::Search::IndexSettings.new(remove_words_if_no_results: "none")
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings = IndexSettings(
            removeWordsIfNoResults = Some(RemoveWordsIfNoResults.withName("none"))
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response = try await client.setSettings(
          indexName: "INDEX_NAME",
          indexSettings: IndexSettings(removeWordsIfNoResults: SearchRemoveWordsIfNoResults.`none`)
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      IndexSettings settings = new IndexSettings();
      settings.RemoveWordsIfNoResults = "none";
      // settings.RemoveWordsIfNoResults = "lastWords";
      // settings.RemoveWordsIfNoResults = "firstWords";
      // settings.RemoveWordsIfNoResults = "allOptional";

      index.SetSettings(settings);
      ```

      ```go Go theme={"system"}
      res, err := index.SetSettings(search.Settings{
      	RemoveWordsIfNoResults: opt.RemoveWordsIfNoResults(
      		"none",
      		// "lastWords",
      		// "firstWords",
      		// "allOptional",
      	),
      })
      ```

      ```java Java theme={"system"}
      index.setSettings(
        new IndexSettings().setRemoveWordsIfNoResults(RemoveWordsType.REMOVE_NONE)
        // new IndexSettings().setRemoveWordsIfNoResults(RemoveWordsType.REMOVE_LAST_WORDS)
        // new IndexSettings().setRemoveWordsIfNoResults(RemoveWordsType.REMOVE_FIRST_WORDS)
        // new IndexSettings().setRemoveWordsIfNoResults(RemoveWordsType.REMOVE_ALLOPTIONAL)
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .setSettings({
          removeWordsIfNoResults: "none",
          // removeWordsIfNoResults: 'lastWords'
          // removeWordsIfNoResults: 'firstWords'
          // removeWordsIfNoResults: 'allOptional'
        })
        .then(() => {
          // done
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val settings = settings {
          removeWordsIfNoResults = RemoveWordIfNoResults.None
          // removeWordsIfNoResults = RemoveWordIfNoResults.LastWords
          // removeWordsIfNoResults = RemoveWordIfNoResults.FirstWords
          // removeWordsIfNoResults = RemoveWordIfNoResults.AllOptional
      }

      index.setSettings(settings)
      ```

      ```php PHP theme={"system"}
      $index->setSettings([
        'removeWordsIfNoResults' => 'none'
        // 'removeWordsIfNoResults' => 'lastWords'
        // 'removeWordsIfNoResults' => 'firstWords'
        // 'removeWordsIfNoResults' => 'allOptional'
      ]);
      ```

      ```python Python theme={"system"}
      index.set_settings(
          {
              "removeWordsIfNoResults": "none"
              # 'removeWordsIfNoResults': 'lastWords'
              # 'removeWordsIfNoResults': 'firstWords'
              # 'removeWordsIfNoResults': 'allOptional'
          }
      )
      ```

      ```ruby Ruby theme={"system"}
      index.set_settings(
        {
          removeWordsIfNoResults: "none"
          # removeWordsIfNoResults: 'lastWords'
          # removeWordsIfNoResults: 'firstWords'
          # removeWordsIfNoResults: 'allOptional'
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        setSettings of "myIndex" `with` IndexSettings(
          removeWordsIfNoResults = Some("none")
          // removeWordsIfNoResults = Some("lastWords")
          // removeWordsIfNoResults = Some("firstWords")
          // removeWordsIfNoResults = Some("allOptional")
        )
      }
      ```

      ```swift Swift theme={"system"}
      let settings = Settings()
        .set(\.removeWordsIfNoResults, to: RemoveWordIfNoResults.none)
        //.set(\.removeWordsIfNoResults, to: .lastWords)
        //.set(\.removeWordsIfNoResults, to: .firstWords)
        //.set(\.removeWordsIfNoResults, to: .allOptional)

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