filters - Algolia

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, 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
Example: category:Book
→ Matches records where category is Book Facet names are case-sensitive, facet values aren’t.
Boolean filters Syntax: facet:true or facet:false
Example: isEnabled:true
→ Matches records where isEnabled is true or "true"
Numeric comparisons Syntax: facet <operator> value
Operators: <, <=, =, !=, >=, >
Example: price > 12.99
Numeric ranges Syntax: facet:low TO high
Example: price:5.99 TO 100
→ Includes both bounds.
Tag filters Syntax: _tags:value or value
Example: published
→ Matches records where _tags is published.
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

Current API clients

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(
    new SearchParamsObject
    {
      Query = "query",
      Filters = "(category:Book OR category:Ebook) AND _tags:published",
    }
  )
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    filters: "(category:Book OR category:Ebook) AND _tags:published",
  ),
);

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

SearchResponse response = client.searchSingleIndex(
  "INDEX_NAME",
  new SearchParamsObject().setQuery("query").setFilters("(category:Book OR category:Ebook) AND _tags:published"),
  Hit.class
);

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

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams =
      SearchParamsObject(
        query = "query",
        filters = "(category:Book OR category:Ebook) AND _tags:published",
      ),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'filters' => '(category:Book OR category:Ebook) AND _tags:published',
    ],
);

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

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(
    query: "query",
    filters: "(category:Book OR category:Ebook) AND _tags:published"
  )
)

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

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

Legacy API clients

index.Search(new Query("query")
{
    Filters = "(category:Book OR category:Ebook) AND _tags:published"
});

res, err := index.Search(
	"query",
	opt.Filters("(category:Book OR category:Ebook) AND _tags:published"),
)

index.search(
  new Query("query")
    .setFilters("(category:Book OR category:Ebook) AND _tags:published")
);

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

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

$index->search('query', [
  'filters' => '(category:Book OR category:Ebook) AND _tags:published'
]);

index.search(
    "query", {"filters": "(category:Book OR category:Ebook) AND _tags:published"}
)

index.search(
  "query",
  {
    filters: "(category:Book OR category:Ebook) AND _tags:published"
  }
)

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

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

Complex filters

Current API clients

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

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

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

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

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

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

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

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

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

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

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

Legacy API clients

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

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)

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

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

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

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

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

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

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

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

Attributes with spaces

Current API clients

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(
    new SearchParamsObject { Query = "query", Filters = "category:\"Books and Comics\"" }
  )
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    filters: "category:\"Books and Comics\"",
  ),
);

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

SearchResponse response = client.searchSingleIndex(
  "INDEX_NAME",
  new SearchParamsObject().setQuery("query").setFilters("category:\"Books and Comics\""),
  Hit.class
);

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

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams =
      SearchParamsObject(query = "query", filters = "category:\"Books and Comics\""),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'filters' => 'category:"Books and Comics"',
    ],
);

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

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(query: "query", filters: "category:\"Books and Comics\"")
)

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

let response: SearchResponse<Hit> = try await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
        query: "query",
        filters: "category:\"Books and Comics\""
    ))
)

Legacy API clients

index.Search(new Query("query")
{
    Filters = "category:'Books and Comics'"
});

res, err := index.Search(
	"query",
	opt.Filters("category:'Books and Comics'"),
)

index.search(
  new Query("query")
    .setFilters("category:'Books and Comics'")
);

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

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

$index->search('query', [
  'filters' => "category:'Books and Comics'"
]);

index.search("query", {"filters": "category:'Books and Comics'"})

index.search(
  "query",
  {
    filters: "category:'Books and Comics'"
  }
)

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

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

Attributes conflicting with keywords

Current API clients

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(new SearchParamsObject { Query = "query", Filters = "keyword:\"OR\"" })
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    filters: "keyword:\"OR\"",
  ),
);

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

SearchResponse response = client.searchSingleIndex(
  "INDEX_NAME",
  new SearchParamsObject().setQuery("query").setFilters("keyword:\"OR\""),
  Hit.class
);

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

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = SearchParamsObject(query = "query", filters = "keyword:\"OR\""),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'filters' => 'keyword:"OR"',
    ],
);

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

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(query: "query", filters: "keyword:\"OR\"")
)

val response = Await.result(
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams = Some(
      SearchParamsObject(
        query = Some("query"),
        filters = Some("keyword:\"OR\"")
      )
    )
  ),
  Duration(100, "sec")
)

let response: SearchResponse<Hit> = try await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
        query: "query",
        filters: "keyword:\"OR\""
    ))
)

Legacy API clients

index.Search(new Query("query")
{
    Filters = "keyword:'OR'"
});

res, err := index.Search(
	"query",
	opt.Filters("keyword:'OR'"),
)

index.search(
  new Query("query")
    .setFilters("keyword:'OR'")
);

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

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

$index->search('query', [
  'filters' => "keyword:'OR'"
]);

index.search("query", {"filters": "keyword:'OR'"})

index.search(
  "query",
  {
    filters: "keyword:'OR'"
  }
)

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

let query = Query("query")
  .set(\.filters, to: "keyword:'OR'")

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

Attributes with single quotes

Current API clients

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(
    new SearchParamsObject { Query = "query", Filters = "content:\"It's a wonderful day\"" }
  )
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    filters: "content:\"It's a wonderful day\"",
  ),
);

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

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

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

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams =
      SearchParamsObject(query = "query", filters = "content:\"It's a wonderful day\""),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'filters' => "content:\"It's a wonderful day\"",
    ],
);

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

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(query: "query", filters: "content:\"It's a wonderful day\"")
)

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

let response: SearchResponse<Hit> = try await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
        query: "query",
        filters: "content:\"It's a wonderful day\""
    ))
)

Legacy API clients

index.Search(new Query("query")
{
    Filters = "content:'It\\'s a wonderful day'"
});

res, err := index.Search(
	"query",
	opt.Filters("content:'It\\'s a wonderful day'"),
)

index.search(
  new Query("query")
    .setFilters("content:'It\\'s a wonderful day'")
);

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

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

$index->search('query', [
  'filters' => "content:'It\\'s a wonderful day'"
]);

index.search("query", {"filters": "content:'It\\'s a wonderful day'"})

index.search(
  "query",
  {
    filters: "content:'It\\'s a wonderful day'"
  }
)

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

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

Attributes with double quotes

Current API clients

var response = await client.SearchSingleIndexAsync<Hit>(
  "INDEX_NAME",
  new SearchParams(
    new SearchParamsObject { Query = "query", Filters = "content:\"She said \"Hello World\"" }
  )
);

final response = await client.searchSingleIndex(
  indexName: "INDEX_NAME",
  searchParams: SearchParamsObject(
    query: "query",
    filters: "content:\"She said \"Hello World\"",
  ),
);

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

SearchResponse response = client.searchSingleIndex(
  "INDEX_NAME",
  new SearchParamsObject().setQuery("query").setFilters("content:\"She said \"Hello World\""),
  Hit.class
);

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

var response =
  client.searchSingleIndex(
    indexName = "INDEX_NAME",
    searchParams =
      SearchParamsObject(query = "query", filters = "content:\"She said \"Hello World\""),
  )

$response = $client->searchSingleIndex(
    'INDEX_NAME',
    ['query' => 'query',
        'filters' => 'content:"She said "Hello World"',
    ],
);

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

response = client.search_single_index(
  "INDEX_NAME",
  Algolia::Search::SearchParamsObject.new(query: "query", filters: "content:\"She said \"Hello World\"")
)

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

let response: SearchResponse<Hit> = try await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
        query: "query",
        filters: "content:\"She said \"Hello World\""
    ))
)

Legacy API clients

index.Search(new Query("query")
{
    Filters = "content:'She said \"Hello World\"'"
});

res, err := index.Search(
	"query",
	opt.Filters("content:'She said \"Hello World\"'"),
)

index.search(
  new Query("query")
    .setFilters("content:'She said \"Hello World\"'")
);

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

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

index.search(query)

$index->search('query', [
  'filters' => "content:'She said \"Hello World\"'"
]);

index.search("query", {"filters": "content:'She said \"Hello World\"'"})

index.search(
  "query",
  {
    filters: "content:'She said \"Hello World\"'"
  }
)

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

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

​Usage

​Filter types

​Examples

​Apply filters on a search query

​Complex filters

​Attributes with spaces

​Attributes conflicting with keywords

​Attributes with single quotes

​Attributes with double quotes

Usage

Filter types

Examples

Apply filters on a search query

Complex filters

Attributes with spaces

Attributes conflicting with keywords

Attributes with single quotes

Attributes with double quotes