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

# filters

> Filter by numeric, facet, or tag filters

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="string" default="" defaultNote="no filters" scope="search" />

The `filters` parameter lets you specify numeric,
facet, and tag filters using an SQL-like syntax with support for boolean operators and parentheses.

## Usage

* All filterable attributes must be listed in [`attributesForFaceting`](/doc/api-reference/api-parameters/attributesForFaceting),
  except for `_tags`, which is always available.
* You can combine filters using `AND`, `OR`, and `NOT`, and group expressions with parentheses.
* Use quotes for:
  * Attribute names or values with spaces.
  * Values that conflict with keywords (`AND`, `OR`, `NOT`).
  * Values that contain single (`'`) or double (`"`) quotes.

### Filter types

* **Facet filters**

  Syntax: `facet:value`<br />
  Example: `category:Book`<br />
  → Matches records where `category` is `Book`

  Facet names are case-sensitive, facet values aren't.

* **Boolean filters**

  Syntax: `facet:true` or `facet:false`<br />
  Example: `isEnabled:true`<br />
  → Matches records where `isEnabled` is `true` or `"true"`

* **Numeric comparisons**

  Syntax: `facet <operator> value`<br />
  Operators: `<`, `<=`, `=`, `!=`, `>=`, `>`<br />
  Example: `price > 12.99`

* **Numeric ranges**

  Syntax: `facet:low TO high`<br />
  Example: `price:5.99 TO 100`<br />
  → Includes both bounds.

* **Tag filters**

  Syntax: `_tags:value` or `value`<br />
  Example: `published`<br />
  → Matches records where `_tags` is `published`.<br />
  Tag matching is case-sensitive.

* **Array attributes**

  A filter matches if it matches **any** element in the array.
  Example: `genres:thriller` matches `genres: ["fiction", "thriller", "sci-fi"]`.

* **Nested attributes**

  You can filter nested fields if they're declared in `attributesForFaceting`.
  Example: `authors.mainAuthor:"John Doe"`.

## Examples

### Apply filters on a search query

<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",
            Filters = "(category:Book OR category:Ebook) AND _tags:published",
          }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          filters: "(category:Book OR category:Ebook) AND _tags:published",
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFilters("(category:Book OR category:Ebook) AND _tags:published"))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject().setQuery("query").setFilters("(category:Book OR category:Ebook) AND _tags:published"),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', filters: '(category:Book OR category:Ebook) AND _tags:published' },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(
              query = "query",
              filters = "(category:Book OR category:Ebook) AND _tags:published",
            ),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'filters' => '(category:Book OR category:Ebook) AND _tags:published',
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "filters": "(category:Book OR category:Ebook) AND _tags:published",
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(
          query: "query",
          filters: "(category:Book OR category:Ebook) AND _tags:published"
        )
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              filters = Some("(category:Book OR category:Ebook) AND _tags:published")
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              filters: "(category:Book OR category:Ebook) AND _tags:published"
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          Filters = "(category:Book OR category:Ebook) AND _tags:published"
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.Filters("(category:Book OR category:Ebook) AND _tags:published"),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setFilters("(category:Book OR category:Ebook) AND _tags:published")
      );
      ```

      ```js JavaScript theme={"system"}
      index.search('query', {
        filters: '(category:Book OR category:Ebook) AND _tags:published'
      }).then({ hits } => {
        console.log(hits);
      });
      ```

      ```kotlin Kotlin theme={"system"}
      // "(category:Book OR category:Ebook) AND _tags:published"
      val query = query("query") {
          filters {
              orFacet {
                  facet("category", "Book")
                  facet("category", "Ebook")
              }
              and {
                  tag("published")
              }
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $index->search('query', [
        'filters' => '(category:Book OR category:Ebook) AND _tags:published'
      ]);
      ```

      ```python Python theme={"system"}
      index.search(
          "query", {"filters": "(category:Book OR category:Ebook) AND _tags:published"}
      )
      ```

      ```ruby Ruby theme={"system"}
      index.search(
        "query",
        {
          filters: "(category:Book OR category:Ebook) AND _tags:published"
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          filters = Some("(category:Book OR category:Ebook) AND _tags:published")
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.filters, to: "(category:Book OR category:Ebook) AND _tags:published")

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

### Complex filters

<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",
            Filters =
              "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"",
          }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          filters:
              "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"",
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().
          SetQuery("query").
          SetFilters("available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND 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")
          .setFilters(
            "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published" +
              " AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND" +
              " author:\"John Doe\""
          ),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: {
          query: 'query',
          filters:
            'available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:"John Doe"',
        },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(
              query = "query",
              filters =
                "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"",
            ),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'filters' => 'available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:"John Doe"',
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "filters": 'available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:"John Doe"',
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(
          query: "query",
          filters: "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\""
        )
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              filters = Some(
                "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND 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",
              filters: "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\""
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      string filters = "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"";

      index.Search(new Query("query")
      {
          Filters = filters
      });
      ```

      ```go Go theme={"system"}
      filters := opt.Filters(
        "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"",
      )

      res, err := index.Search("query", filters)
      ```

      ```java Java theme={"system"}
      String filters = new String(
        "available = 1"
        + " AND (category:Book OR NOT category:Ebook)"
        + " AND _tags:published"
        + " AND publication_date:1441745506 TO 1441755506"
        + " AND inStock > 0"
        + " AND author:\"John Doe\""
      );

      index.search(
        new Query("query")
          .setFilters(filters)
      );
      ```

      ```js JavaScript theme={"system"}
      const filters =
        'available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:"John Doe"';

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

      ```kotlin Kotlin theme={"system"}
      //  available = 1
      //  AND (category:Book OR NOT category:Ebook)
      //  AND _tags:published
      //  AND publication_date:1441745506 TO 1441755506
      //  AND inStock > 0
      //  AND author:\"John Doe\"";
      val query = query("query") {
          filters {
              and {
                  comparison("available", Equals, 1)
                  tag("published")
                  range("publication_date", 1441745506..1441755506)
                  comparison("inStock", NumericOperator.Greater, 0)
                  facet("author", "John Doe")
              }
              orFacet {
                  facet("category", "Book")
                  facet("category", "EBook", isNegated = true)
              }
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $filters = 'available = 1'.
                ' AND (category:Book OR NOT category:Ebook)'.
                ' AND _tags:published'.
                ' AND publication_date:1441745506 TO 1441755506'.
                ' AND inStock > 0'.
                ' AND author:"John Doe"';

      $index->search('query', [
        'filters' => $filters
      ]);
      ```

      ```python Python theme={"system"}
      filters = 'available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:"John Doe"'

      index.search("query", {"filters": filters})
      ```

      ```ruby Ruby theme={"system"}
      filters = "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\""

      index.search(
        "query",
        {
          filters: filters
        }
      )
      ```

      ```scala Scala theme={"system"}
      val filters = Some("available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"")

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

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.filters, to: "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"")

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

### Attributes with spaces

<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", Filters = "category:\"Books and Comics\"" }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          filters: "category:\"Books and Comics\"",
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFilters("category:\"Books and Comics\""))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject().setQuery("query").setFilters("category:\"Books and Comics\""),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', filters: 'category:"Books and Comics"' },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(query = "query", filters = "category:\"Books and Comics\""),
        )
      ```

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

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "filters": 'category:"Books and Comics"',
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", filters: "category:\"Books and Comics\"")
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              filters = Some("category:\"Books and Comics\"")
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              filters: "category:\"Books and Comics\""
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          Filters = "category:'Books and Comics'"
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.Filters("category:'Books and Comics'"),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setFilters("category:'Books and Comics'")
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          filters: 'category:"Books and Comics"',
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      // "\"category\":\"Books and Comics\""
      val query = query("query") {
          filters {
              and {
                  // You don't have to escape strings, it is done for you.
                  facet("category", "Books and Comics")
              }
          }
      }
      index.search(query)
      ```

      ```php PHP theme={"system"}
      $index->search('query', [
        'filters' => "category:'Books and Comics'"
      ]);
      ```

      ```python Python theme={"system"}
      index.search("query", {"filters": "category:'Books and Comics'"})
      ```

      ```ruby Ruby theme={"system"}
      index.search(
        "query",
        {
          filters: "category:'Books and Comics'"
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          filters = Some("category:'Books and Comics'")
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.filters, to: "category:'Books and Comics'")

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

### Attributes conflicting with keywords

<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", Filters = "keyword:\"OR\"" })
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          filters: "keyword:\"OR\"",
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFilters("keyword:\"OR\""))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject().setQuery("query").setFilters("keyword:\"OR\""),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', filters: 'keyword:"OR"' },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = SearchParamsObject(query = "query", filters = "keyword:\"OR\""),
        )
      ```

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

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "filters": 'keyword:"OR"',
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", filters: "keyword:\"OR\"")
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              filters = Some("keyword:\"OR\"")
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              filters: "keyword:\"OR\""
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          Filters = "keyword:'OR'"
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.Filters("keyword:'OR'"),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setFilters("keyword:'OR'")
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          filters: 'keyword:"OR"',
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      // "\"keyword\":\"OR\""
      val query = query("query") {
          filters {
              and {
                  // You don't have to escape keywords, it is done for you.
                  facet("keyword", "OR")
              }
          }
      }
      index.search(query)
      ```

      ```php PHP theme={"system"}
      $index->search('query', [
        'filters' => "keyword:'OR'"
      ]);
      ```

      ```python Python theme={"system"}
      index.search("query", {"filters": "keyword:'OR'"})
      ```

      ```ruby Ruby theme={"system"}
      index.search(
        "query",
        {
          filters: "keyword:'OR'"
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          filters = Some("keyword:'OR'")
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.filters, to: "keyword:'OR'")

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

### Attributes with single quotes

<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", Filters = "content:\"It's a wonderful day\"" }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          filters: "content:\"It's a wonderful day\"",
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFilters("content:\"It's a wonderful day\""))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject().setQuery("query").setFilters("content:\"It's a wonderful day\""),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', filters: 'content:"It\'s a wonderful day"' },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(query = "query", filters = "content:\"It's a wonderful day\""),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'filters' => "content:\"It's a wonderful day\"",
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "filters": 'content:"It\'s a wonderful day"',
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", filters: "content:\"It's a wonderful day\"")
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              filters = Some("content:\"It's a wonderful day\"")
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              filters: "content:\"It's a wonderful day\""
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          Filters = "content:'It\\'s a wonderful day'"
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.Filters("content:'It\\'s a wonderful day'"),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setFilters("content:'It\\'s a wonderful day'")
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          filters: 'content:"It\'s a wonderful day"',
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      // "\"content\":\"It's a wonderful day\""
      val query = query("query") {
          filters {
              and {
                  // You don't have to escape single quotes, it is done for you.
                  facet("content", "It's a wonderful day")
              }
          }
      }
      index.search(query)
      ```

      ```php PHP theme={"system"}
      $index->search('query', [
        'filters' => "content:'It\\'s a wonderful day'"
      ]);
      ```

      ```python Python theme={"system"}
      index.search("query", {"filters": "content:'It\\'s a wonderful day'"})
      ```

      ```ruby Ruby theme={"system"}
      index.search(
        "query",
        {
          filters: "content:'It\\'s a wonderful day'"
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          filters = Some("content:'It\\'s a wonderful day'")
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.filters, to: "content:'It\\'s a wonderful day'")

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

### Attributes with double quotes

<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", Filters = "content:\"She said \"Hello World\"" }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          filters: "content:\"She said \"Hello World\"",
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetFilters("content:\"She said \"Hello World\""))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject().setQuery("query").setFilters("content:\"She said \"Hello World\""),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', filters: 'content:"She said "Hello World"' },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(query = "query", filters = "content:\"She said \"Hello World\""),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'filters' => 'content:"She said "Hello World"',
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "filters": 'content:"She said "Hello World"',
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", filters: "content:\"She said \"Hello World\"")
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              filters = Some("content:\"She said \"Hello World\"")
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              filters: "content:\"She said \"Hello World\""
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          Filters = "content:'She said \"Hello World\"'"
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.Filters("content:'She said \"Hello World\"'"),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query")
          .setFilters("content:'She said \"Hello World\"'")
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          filters: 'content:"She said \\"Hello World\\""',
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      // "\"content\":\"She said Hello World\""
      val query = query("query") {
          filters {
              and {
                  facet("content", "She said \"Hello World\"")
              }
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $index->search('query', [
        'filters' => "content:'She said \"Hello World\"'"
      ]);
      ```

      ```python Python theme={"system"}
      index.search("query", {"filters": "content:'She said \"Hello World\"'"})
      ```

      ```ruby Ruby theme={"system"}
      index.search(
        "query",
        {
          filters: "content:'She said \"Hello World\"'"
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          filters = Some("content:'She said \"Hello World\"'")
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.filters, to: "content:'She said \"Hello World\"'")

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