numericFilters

In most cases, prefer using the 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 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 and numericFilters. For example:

JavaScript

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

Current API clients

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"),
            }
          ),
        }
      ),
    }
  )
);

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

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)
}

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
);

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

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"),
                )
              ),
            )
          ),
      ),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'numericFilters' => [
            'price < 1000',

            [
                'inStock = 1',

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

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

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(
    query: "query",
    numeric_filters: ["price < 1000", ["inStock = 1", "deliveryDate < 1441755506"]]
  )
)

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

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"),
            ]),
        ])
    ))
)

Legacy API clients

index.Search(new Query("query")
{
    NumericFilters = new List>
    {
      new List { "inStock = 1", "deliveryDate < 1441755506"  },
      new List { "price < 1000" }
    };
});

res, err := index.Search(
	"query",
	opt.NumericFilterAnd(
		opt.NumericFilterOr("inStock = 1", "deliveryDate < 1441755506"),
		"price < 1000",
	),
)

index.search(
  new Query("query").setNumericFilters(
          Arrays.asList(
                  Arrays.asList(
                          "inStock = 1",
                          "deliveryDate < 1441755506"
                  ),
                  Collections.singletonList("price < 1000")
          )
  )
);

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

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

index.search(query)

$results = $index->search('query', [
  'numericFilters' => [
    [
      "inStock = 1",
      "deliveryDate < 1441755506"
    ],
    "price < 1000"
  ]
]);

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

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

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

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)")
  }
}

Search API endpoints

Index settings/API parameters

Usage

Numeric comparisons

Numeric ranges

Combining with `filters`

Example

​Usage

​Numeric comparisons

​Numeric ranges

​Combining with filters

​Example

Usage

Numeric comparisons

Numeric ranges

Combining with `filters`

Example