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

# numericFilters

> Filter on ranges or comparisons of numeric attributes

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" />

In most cases, prefer using the [`filters`](/doc/api-reference/api-parameters/filters) parameter,
which offers a simpler SQL-like syntax and supports combining numeric, facet, and tag filters.
However, sometimes you might want to [combine `filters` and `numericFilters`](#combining-with-filters) in the same search.

## Usage

* You can't use boolean operators (`AND`, `OR`, `NOT`) inside `numericFilters`.
* Multiple filters in a flat array are combined using `AND`.
  To combine filters with `OR`, use nested arrays.
* Filters support numeric values from `-4611686018427387` to `+4611686018427387`.
* Numeric precision is limited to three decimal places.

### Numeric comparisons

* Syntax: `facet <operator> value`
* Operators: `<`, `<=`, `=`, `!=`, `>=`, `>`.
* Example: `inStock = 1`

### Numeric ranges

* Format: `facet:low TO high`

* Example: `price:5.99 TO 100`

* Both bounds must be numeric.

* Ranges are inclusive.

### Combining with `filters`

You can combine [`filters`](/doc/api-reference/api-parameters/filters) and `numericFilters`.

For example:

```js JavaScript theme={"system"}
index.search("", {
  filters: '("county:Maricopa" OR "county:Pima")',
  numericFilters: ["employees > 500"],
});
```

This returns results with more than 500 employees and the county is either Maricopa or Pima.

## 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",
            NumericFilters = new NumericFilters(
              new List<NumericFilters>
              {
                new NumericFilters("price < 1000"),
                new NumericFilters(
                  new List<NumericFilters>
                  {
                    new NumericFilters("inStock = 1"),
                    new NumericFilters("deliveryDate < 1441755506"),
                  }
                ),
              }
            ),
          }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          numericFilters: [
            "price < 1000",
            [
              "inStock = 1",
              "deliveryDate < 1441755506",
            ],
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetNumericFilters(search.ArrayOfNumericFiltersAsNumericFilters(
          []search.NumericFilters{*search.StringAsNumericFilters("price < 1000"), *search.ArrayOfNumericFiltersAsNumericFilters(
            []search.NumericFilters{*search.StringAsNumericFilters("inStock = 1"), *search.StringAsNumericFilters("deliveryDate < 1441755506")})})))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject()
          .setQuery("query")
          .setNumericFilters(
            NumericFilters.of(
              Arrays.asList(
                NumericFilters.of("price < 1000"),
                NumericFilters.of(Arrays.asList(NumericFilters.of("inStock = 1"), NumericFilters.of("deliveryDate < 1441755506")))
              )
            )
          ),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', numericFilters: ['price < 1000', ['inStock = 1', 'deliveryDate < 1441755506']] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(
              query = "query",
              numericFilters =
                NumericFilters.of(
                  listOf(
                    NumericFilters.of("price < 1000"),
                    NumericFilters.of(
                      listOf(
                        NumericFilters.of("inStock = 1"),
                        NumericFilters.of("deliveryDate < 1441755506"),
                      )
                    ),
                  )
                ),
            ),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'numericFilters' => [
                  'price < 1000',

                  [
                      'inStock = 1',

                      'deliveryDate < 1441755506',
                  ],
              ],
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "numericFilters": [
                  "price < 1000",
                  [
                      "inStock = 1",
                      "deliveryDate < 1441755506",
                  ],
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(
          query: "query",
          numeric_filters: ["price < 1000", ["inStock = 1", "deliveryDate < 1441755506"]]
        )
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              numericFilters = Some(
                NumericFilters(
                  Seq(
                    NumericFilters("price < 1000"),
                    NumericFilters(Seq(NumericFilters("inStock = 1"), NumericFilters("deliveryDate < 1441755506")))
                  )
                )
              )
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              numericFilters: SearchNumericFilters.arrayOfSearchNumericFilters([
                  SearchNumericFilters.string("price < 1000"),
                  SearchNumericFilters.arrayOfSearchNumericFilters([
                      SearchNumericFilters.string("inStock = 1"),
                      SearchNumericFilters.string("deliveryDate < 1441755506"),
                  ]),
              ])
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          NumericFilters = new List>
          {
            new List { "inStock = 1", "deliveryDate < 1441755506"  },
            new List { "price < 1000" }
          };
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search(
      	"query",
      	opt.NumericFilterAnd(
      		opt.NumericFilterOr("inStock = 1", "deliveryDate < 1441755506"),
      		"price < 1000",
      	),
      )
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query").setNumericFilters(
                Arrays.asList(
                        Arrays.asList(
                                "inStock = 1",
                                "deliveryDate < 1441755506"
                        ),
                        Collections.singletonList("price < 1000")
                )
        )
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          numericFilters: [
            ["inStock = 1", "deliveryDate < 1441755506"],
            "price < 1000",
          ],
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val query = query("query") {
          numericFilters {
              or {
                  comparison("inStock", Equals, 0f)
                  comparison("deliveryDate", Less, 1441755506)
              }
              and {
                  comparison("price", Less, 1000)
              }
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $results = $index->search('query', [
        'numericFilters' => [
          [
            "inStock = 1",
            "deliveryDate < 1441755506"
          ],
          "price < 1000"
        ]
      ]);
      ```

      ```python Python theme={"system"}
      results = index.search(
          "query",
          {"numericFilters": [["inStock = 1", "deliveryDate < 1441755506"], "price < 1000"]},
      )
      ```

      ```ruby Ruby theme={"system"}
      results = index.search(
        "query",
        {
          numericFilters: [
            [
              "inStock = 1",
              "deliveryDate < 1441755506"
            ],
            "price < 1000"
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          numericFilters = Some(Seq(
            Some(Seq(
              "inStock = 1",
              "deliveryDate < 1441755506"
            )),
            "price < 1000"
          ))
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.numericFilters, to: [
          .or("inStock = 1", "deliveryDate < 1441755506"),
          "price < 1000"
        ])

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