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

# advancedSyntaxFeatures

> Enable support for phrase matching and word exclusion in query syntax

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<enum<string>>" default="[&#x22;exactPhrase&#x22;, &#x22;excludeWords&#x22;]" scope="settings,search" />

The `advancedSyntaxFeatures` parameter defines which advanced query features are enabled when [`advancedSyntax`](/doc/api-reference/api-parameters/advancedSyntax) is set to `true`.

## Options

<ParamField path="exactPhrase">
  Enables exact phrase matching with double quotes (`"`).
  For example, `"search engine"` only matches records where "search" is followed by "engine" in a searchable attribute.\
  Typo tolerance is not applied inside quoted phrases.
</ParamField>

<ParamField path="excludeWords">
  Enables word exclusion using the minus sign (`-`).
  For example, `search -engine` matches records that contain "search" but **not** "engine".
</ParamField>

## Example

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

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          advancedSyntax: true,
          advancedSyntaxFeatures: [
            AdvancedSyntaxFeatures.fromJson("exactPhrase"),
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetAdvancedSyntax(true).SetAdvancedSyntaxFeatures(
          []search.AdvancedSyntaxFeatures{search.AdvancedSyntaxFeatures("exactPhrase")}))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject()
          .setQuery("query")
          .setAdvancedSyntax(true)
          .setAdvancedSyntaxFeatures(Arrays.asList(AdvancedSyntaxFeatures.EXACT_PHRASE)),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', advancedSyntax: true, advancedSyntaxFeatures: ['exactPhrase'] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(
              query = "query",
              advancedSyntax = true,
              advancedSyntaxFeatures =
                listOf(AdvancedSyntaxFeatures.entries.first { it.value == "exactPhrase" }),
            ),
        )
      ```

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

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "advancedSyntax": True,
              "advancedSyntaxFeatures": [
                  "exactPhrase",
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(
          query: "query",
          advanced_syntax: true,
          advanced_syntax_features: ["exactPhrase"]
        )
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              advancedSyntax = Some(true),
              advancedSyntaxFeatures = Some(Seq(AdvancedSyntaxFeatures.withName("exactPhrase")))
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              advancedSyntax: true,
              advancedSyntaxFeatures: [SearchAdvancedSyntaxFeatures.exactPhrase]
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query {
        AdvancedSyntax = true,
        AdvancedSyntaxFeatures = new List { "exactPhrase" }
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.AdvancedSyntax(true),
      	opt.AdvancedSyntaxFeatures("exactPhrase"),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setAdvancedSyntax(true)
          .setAdvancedSyntaxFeatures(Arrays.asList("exactPhrase"))
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          advancedSyntax: true,
          advancedSyntaxFeatures: ["exactPhrase"],
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val query = query("query") {
          advancedSyntax = true
          advancedSyntaxFeatures {
              +ExactPhrase
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $results = $index->search('query', [
        'advancedSyntax' => true,
        'advancedSyntaxFeatures' => ['exactPhrase']
      ]);
      ```

      ```python Python theme={"system"}
      results = index.search(
          "query", {"advancedSyntax": True, "advancedSyntaxFeatures": ["exactPhrase"]}
      )
      ```

      ```ruby Ruby theme={"system"}
      results = index.search(
        "query",
        {
          advancedSyntax: true,
          advancedSyntaxFeatures: ["exactPhrase"]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query string"),
          advancedSyntax = Some(true),
          advancedSyntaxFeatures = Some(Seq("exactPhrase"))
        )
      }
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>