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

# facetFilters

> Filter search results by facet values

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<string>" default="[]" scope="search" />

<Tip>
  Use the [`filters`](/doc/api-reference/api-parameters/filters) parameter instead. It supports boolean combinations of multiple filters, and unifies `numericFilters`, `tagFilters`, `facetFilters` into a single syntax.
</Tip>

## Usage

To use an attribute as facet filter, it must be included in the [`attributesForFaceting`](/doc/api-reference/api-parameters/attributesForFaceting) setting.

### Single facet filter

Specify a filter using the `"facet:value"` syntax. For example, `"genre:comedy"` returns only records where the `genre` attribute is `comedy`.

### Negative filter

Prefix the value with a minus sign to exclude matches: `"facet:-value"`. For example, `"genre:-comedy"` excludes records where `genre` is `comedy`.

### Combining filters with `AND` and `OR`

Use a flat array for `AND` conditions: `["category:Book", "author:John Doe"]` returns records where `category` is `Book` **and** `author` is `John Doe`.

Use nested arrays for `OR` conditions:\
`[["genre:comedy", "genre:drama"]]` returns records where `genre` is either `comedy` **or** `drama`.

You can combine `AND` with `OR`: `[["category:Book", "category:Movie"], "author:John Doe"]` means `(category:Book OR category:Movie) AND author:John Doe`.

<Note>
  You can't group `AND` conditions inside an `OR` group. `(A AND B) OR C` is invalid.
</Note>

### Escape minus signs

If a facet value starts with `-`, escape it with a backslash: `category:\-Movie`.

This also applies to negative numbers: `"count:\-12"` matches string or numeric values equal to -12. To filter only numeric values, use [`numericFilters`](/doc/api-reference/api-parameters/numericFilters).

## Examples

### Single facet filter

<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",
            FacetFilters = new FacetFilters(
              new List<FacetFilters> { new FacetFilters("category:Book") }
            ),
          }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          facetFilters: [
            "category:Book",
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFacetFilters(search.ArrayOfFacetFiltersAsFacetFilters(
          []search.FacetFilters{*search.StringAsFacetFilters("category:Book")})))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject().setQuery("query").setFacetFilters(FacetFilters.of(Arrays.asList(FacetFilters.of("category:Book")))),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', facetFilters: ['category:Book'] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(
              query = "query",
              facetFilters = FacetFilters.of(listOf(FacetFilters.of("category:Book"))),
            ),
        )
      ```

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

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "facetFilters": [
                  "category:Book",
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", facet_filters: ["category:Book"])
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              facetFilters = Some(FacetFilters(Seq(FacetFilters("category:Book"))))
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              facetFilters: SearchFacetFilters.arrayOfSearchFacetFilters([SearchFacetFilters.string("category:Book")])
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          FacetFilters = new List> { new List { "category:Book" } } };
      });
      ```

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

      ```java Java theme={"system"}
      index.search(
        new Query("query")
                .setFacetFilters(Collections.singletonList(
                        Collections.singletonList("category:Book")
                ))
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          facetFilters: ["category:Book"],
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val query = query("query") {
          facetFilters {
              and { facet("category", "Book") }
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $results = $index->search('query', [
        'facetFilters' => [
          "category:Book"
        ]
      ]);
      ```

      ```python Python theme={"system"}
      results = index.search("query", {"facetFilters": ["category:Book"]})
      ```

      ```ruby Ruby theme={"system"}
      results = index.search(
        "query",
        {
          facetFilters: [
            "category:Book"
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          facetFilters = Some(Seq(
            "category:Book"
          ))
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.facetFilters, to: [
          "category:Book"
        ]
      )

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

### Two filters with `AND`

<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",
            FacetFilters = new FacetFilters(
              new List<FacetFilters>
              {
                new FacetFilters("category:Book"),
                new FacetFilters("author:John Doe"),
              }
            ),
          }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          facetFilters: [
            "category:Book",
            "author:John Doe",
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFacetFilters(search.ArrayOfFacetFiltersAsFacetFilters(
          []search.FacetFilters{*search.StringAsFacetFilters("category:Book"), *search.StringAsFacetFilters("author:John Doe")})))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject()
          .setQuery("query")
          .setFacetFilters(FacetFilters.of(Arrays.asList(FacetFilters.of("category:Book"), FacetFilters.of("author:John Doe")))),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', facetFilters: ['category:Book', 'author:John Doe'] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(
              query = "query",
              facetFilters =
                FacetFilters.of(
                  listOf(FacetFilters.of("category:Book"), FacetFilters.of("author:John Doe"))
                ),
            ),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'facetFilters' => [
                  'category:Book',

                  'author:John Doe',
              ],
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "facetFilters": [
                  "category:Book",
                  "author:John Doe",
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", facet_filters: ["category:Book", "author:John Doe"])
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              facetFilters = Some(FacetFilters(Seq(FacetFilters("category:Book"), FacetFilters("author:John Doe"))))
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              facetFilters: SearchFacetFilters.arrayOfSearchFacetFilters([
                  SearchFacetFilters.string("category:Book"),
                  SearchFacetFilters.string("author:John Doe"),
              ])
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
        FacetFilters = new List>
        {
          new List { "category:Book" },
          new List { "author:John Doe" },
        }
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.FacetFilterAnd("category:Book", "author:John Doe"),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setFacetFilters(Arrays.asList(
             Collections.singletonList("category:Book"),
             Collections.singletonList("author:John Doe"),
          ))
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          facetFilters: ["category:Book", "author:John Doe"],
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val query = query("query") {
          facetFilters {
              and {
                  facet("category", "Book")
                  facet("author", "John Doe")
              }
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $results = $index->search('query', [
        'facetFilters' => [
          "category:Book",
          "author:John Doe"
        ]
      ]);
      ```

      ```python Python theme={"system"}
      results = index.search("query", {"facetFilters": ["category:Book", "author:John Doe"]})
      ```

      ```ruby Ruby theme={"system"}
      results = index.search(
        "query",
        {
          facetFilters: [
            "category:Book",
            "author:John Doe"
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          facetFilters = Some(Seq(
            "category:Book",
            "author:John Doe"
          ))
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.facetFilters, to: [
          "category:Book", "author:John Doe"
        ]
      )

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

### Two filters with `OR`

<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",
            FacetFilters = new FacetFilters(
              new List<FacetFilters>
              {
                new FacetFilters(
                  new List<FacetFilters>
                  {
                    new FacetFilters("category:Book"),
                    new FacetFilters("author:John Doe"),
                  }
                ),
              }
            ),
          }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          facetFilters: [
            [
              "category:Book",
              "author:John Doe",
            ],
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFacetFilters(search.ArrayOfFacetFiltersAsFacetFilters(
          []search.FacetFilters{*search.ArrayOfFacetFiltersAsFacetFilters(
            []search.FacetFilters{*search.StringAsFacetFilters("category:Book"), *search.StringAsFacetFilters("author:John Doe")})})))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject()
          .setQuery("query")
          .setFacetFilters(
            FacetFilters.of(
              Arrays.asList(FacetFilters.of(Arrays.asList(FacetFilters.of("category:Book"), FacetFilters.of("author:John Doe"))))
            )
          ),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', facetFilters: [['category:Book', 'author:John Doe']] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(
              query = "query",
              facetFilters =
                FacetFilters.of(
                  listOf(
                    FacetFilters.of(
                      listOf(FacetFilters.of("category:Book"), FacetFilters.of("author:John Doe"))
                    )
                  )
                ),
            ),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'facetFilters' => [
                  [
                      'category:Book',

                      'author:John Doe',
                  ],
              ],
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "facetFilters": [
                  [
                      "category:Book",
                      "author:John Doe",
                  ],
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", facet_filters: [["category:Book", "author:John Doe"]])
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              facetFilters =
                Some(FacetFilters(Seq(FacetFilters(Seq(FacetFilters("category:Book"), FacetFilters("author:John Doe"))))))
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              facetFilters: SearchFacetFilters
                  .arrayOfSearchFacetFilters([SearchFacetFilters.arrayOfSearchFacetFilters([
                      SearchFacetFilters.string("category:Book"),
                      SearchFacetFilters.string("author:John Doe"),
                  ])])
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
        FacetFilters = new List>
        {
          new List { "category:Book", "category:Movie" },
        }
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.FacetFilterOr("category:Book", "category:Movie"),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setFacetFilters(Arrays.asList(
            Arrays.asList("category:Book", "category:Movie")
          ))
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          facetFilters: [["category:Book", "category:Movie"]],
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val query = query("query") {
          facetFilters {
              or {
                  facet("category", "Book")
                  facet("category", "Movie")
              }
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $results = $index->search('query', [
        'facetFilters' => [
          ["category:Book", "category:Movie"]
        ]
      ]);
      ```

      ```python Python theme={"system"}
      results = index.search("query", {"facetFilters": [["category:Book", "category:Movie"]]})
      ```

      ```ruby Ruby theme={"system"}
      results = index.search(
        "query",
        {
          facetFilters: [
            ["category:Book", "category:Movie"]
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          facetFilters = Some(Seq(
            Seq("category:Book", "category:Movie")
          ))
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.facetFilters, to: [
          .or("category:Book", "category:Movie")
        ]
      )

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

### Multiple filters with `AND` and `OR`

<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",
            FacetFilters = new FacetFilters(
              new List<FacetFilters>
              {
                new FacetFilters("author:John Doe"),
                new FacetFilters(
                  new List<FacetFilters>
                  {
                    new FacetFilters("category:Book"),
                    new FacetFilters("category:Movie"),
                  }
                ),
              }
            ),
          }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          facetFilters: [
            "author:John Doe",
            [
              "category:Book",
              "category:Movie",
            ],
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFacetFilters(search.ArrayOfFacetFiltersAsFacetFilters(
          []search.FacetFilters{*search.StringAsFacetFilters("author:John Doe"), *search.ArrayOfFacetFiltersAsFacetFilters(
            []search.FacetFilters{*search.StringAsFacetFilters("category:Book"), *search.StringAsFacetFilters("category:Movie")})})))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject()
          .setQuery("query")
          .setFacetFilters(
            FacetFilters.of(
              Arrays.asList(
                FacetFilters.of("author:John Doe"),
                FacetFilters.of(Arrays.asList(FacetFilters.of("category:Book"), FacetFilters.of("category:Movie")))
              )
            )
          ),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', facetFilters: ['author:John Doe', ['category:Book', 'category:Movie']] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(
              query = "query",
              facetFilters =
                FacetFilters.of(
                  listOf(
                    FacetFilters.of("author:John Doe"),
                    FacetFilters.of(
                      listOf(FacetFilters.of("category:Book"), FacetFilters.of("category:Movie"))
                    ),
                  )
                ),
            ),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'facetFilters' => [
                  'author:John Doe',

                  [
                      'category:Book',

                      'category:Movie',
                  ],
              ],
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "facetFilters": [
                  "author:John Doe",
                  [
                      "category:Book",
                      "category:Movie",
                  ],
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(
          query: "query",
          facet_filters: ["author:John Doe", ["category:Book", "category:Movie"]]
        )
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              facetFilters = Some(
                FacetFilters(
                  Seq(
                    FacetFilters("author:John Doe"),
                    FacetFilters(Seq(FacetFilters("category:Book"), FacetFilters("category:Movie")))
                  )
                )
              )
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              facetFilters: SearchFacetFilters.arrayOfSearchFacetFilters([
                  SearchFacetFilters.string("author:John Doe"),
                  SearchFacetFilters.arrayOfSearchFacetFilters([
                      SearchFacetFilters.string("category:Book"),
                      SearchFacetFilters.string("category:Movie"),
                  ]),
              ])
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
        FacetFilters = new List>
        {
          new List { "category:Book", "category:Movie" },
          new List { "author:John Doe" }
        }
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.FacetFilterAnd(
      		opt.FacetFilterOr("category:Book", "category:Movie"),
      		"author:John Doe",
      	),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setFacetFilters(Arrays.asList(
            Arrays.asList("category:Book", "category:Movie"),
            Collections.singletonList("author:John Doe")
          ))
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          facetFilters: [["category:Book", "category:Movie"], "author:John Doe"],
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val query = query("query") {
          facetFilters {
              or {
                  facet("category", "Book")
                  facet("category", "Movie")
              }
              and {
                  facet("author", "John Doe")
              }
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $results = $index->search('query', [
        'facetFilters' => [
          ["category:Book", "category:Movie"],
          "author:John Doe"
        ]
      ]);
      ```

      ```python Python theme={"system"}
      results = index.search(
          "query", {"facetFilters": [["category:Book", "category:Movie"], "author:John Doe"]}
      )
      ```

      ```ruby Ruby theme={"system"}
      results = index.search(
        "query",
        {
          facetFilters: [
            ["category:Book", "category:Movie"],
            "author:John Doe"
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          facetFilters = Some(Seq(
            Seq("category:Book", "category:Movie"),
            "author:John Doe"
          ))
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.facetFilters, to: [
          .or("category:Book", "category:Movie"), "author:John Doe"
        ]
      )

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