> ## Documentation Index > Fetch the complete documentation index at: https://upstash-redis-1-18.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # SEARCH.QUERY > Search documents with a JSON filter. Use `SEARCH.QUERY` to search for documents matching a JSON filter. The filter is a JSON object naming index fields and the values to match, so `'{"name": "headphones", "inStock": true}'` combines conditions with an implicit AND. Text fields are matched with the analysis configured in the schema while other types are matched exactly, and operators such as `$fuzzy`, `$prefix`, `$range`, `$or`, and `$mustNot` cover the cases where plain field matching is not enough. Querying an index that does not exist returns null. Results come back ordered by relevance score by default. `ORDERBY` sorts by a `FAST` field instead, `LIMIT` and `OFFSET` page through the matches, `SELECT` and `NOCONTENT` cut the payload down to the fields you need, `HIGHLIGHT` wraps the matched terms in tags for display, and `SCOREFUNC` blends numeric fields such as popularity or recency into the relevance score. A `KEYWORD` or `TEXT` field whose value is a JSON array is indexed element by element, so a document matches when any element matches the condition. `HIGHLIGHT` preserves that shape: the field comes back as the same array with the matching elements marked up, and elements that did not match, including non-string ones, unchanged. The stored document is never modified. See [Querying and filtering](/redis/search/querying) for the full filter syntax and worked examples, and [`SEARCH.COUNT`](/redis/commands/search/search-count) when you only need the number of matches. ## Syntax ```redis theme={"system"} SEARCH.QUERY '' [LIMIT ] [OFFSET ] [ORDERBY [ASC|DESC]] [SELECT [ ...]] [NOCONTENT] [HIGHLIGHT FIELDS [ ...] [TAGS ]] [SCOREFUNC FIELDVALUE [MODIFIER ] [FACTOR ] [MISSING ] [FIELDVALUE ...] [SCOREMODE ] [COMBINEMODE ]] ``` ## Arguments | Argument | Description | Default | | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | | `LIMIT` | Maximum number of results to return. Must be between 1 and 1000. | `10` | | `OFFSET` | Number of results to skip for pagination. Must be between 0 and 10,000. | `0` | | `ORDERBY` | Sort by a `FAST` field. The direction defaults to `DESC` when omitted. | Relevance score, descending | | `SELECT` | Return only the specified number of document fields. When the schema uses `FROM`, specify the source document field rather than its index alias. | All fields | | `NOCONTENT` | Return keys and scores without document content. | Disabled | | `HIGHLIGHT` | Wrap matching terms in tags. The default tags are `` and ``. | Disabled | | `SCOREFUNC` | Adjust relevance scores using one or more `FAST` numeric fields. `FACTOR` defaults to `1`, `MISSING` to `0`, `MODIFIER` to `NONE`, `SCOREMODE` to `SUM`, and `COMBINEMODE` to `SUM`. | Disabled | `NOCONTENT` cannot be combined with `SELECT` or `HIGHLIGHT`. `SCOREFUNC` cannot be combined with `ORDERBY`. Inside `MULTI` or `EVAL`, the command requires `NOCONTENT`. See [Querying and filtering](/redis/search/querying) for the JSON filter operators and detailed query examples. ## Response Returns an array of `[key, score, content]` results, or `null` if the index does not exist: * `key` is the Redis key of the matching document. * `score` is the floating-point relevance score. * `content` is an array of field-value pairs. JSON indexes return `[["$", ""]]`; hash indexes return `[["field", "value"], ...]`. When `NOCONTENT` is used, each result is `[key, score]`. When `SELECT` is used, only fields that exist in the document appear in the content. For an index created with `ON STREAM`, `key` is the entry ID of the matching stream entry. A highlighted multi-valued field keeps its array form in the reply. Highlighting `a` on a document whose `a` is `["hello world", "foo & bar", 7]` returns `["hello world","foo & bar",7]`. ```text theme={"system"} [ ["key1", 1.25, [["$", "{\"name\":\"...\"}"]]], ["key2", 0.75, [["$", "{\"name\":\"...\"}"]]] ] ``` ## Examples ```bash theme={"system"} SEARCH.QUERY products '{"name": "wireless"}' LIMIT 10 OFFSET 0 ``` ```ts theme={"system"} import { Redis, s } from "@upstash/redis"; const redis = Redis.fromEnv(); const products = redis.search.index({ name: "products", schema: s.object({ name: s.string() }), }); const results = await products.query({ filter: { name: "wireless" }, limit: 10, offset: 0, }); ``` ```python theme={"system"} from upstash_redis import Redis redis = Redis.from_env() products = redis.search.index(name="products") results = products.query( filter={"name": "wireless"}, limit=10, offset=0, ) ``` ```ts theme={"system"} import IORedis from "ioredis"; import { createSearch, s } from "@upstash/search-ioredis"; const redis = new IORedis(process.env.REDIS_URL!); const search = createSearch(redis); const products = search.index({ name: "products", schema: s.object({ name: s.string() }), }); const results = await products.query({ filter: { name: "wireless" }, limit: 10, offset: 0, }); ``` ```ts theme={"system"} import { createClient } from "redis"; import { createSearch, s } from "@upstash/search-redis"; const client = await createClient({ url: process.env.REDIS_URL }) .on("error", console.error) .connect(); const search = createSearch(client); const products = search.index({ name: "products", schema: s.object({ name: s.string() }), }); const results = await products.query({ filter: { name: "wireless" }, limit: 10, offset: 0, }); ``` ```python theme={"system"} import os import redis client = redis.from_url(os.environ["REDIS_URL"]) result = client.execute_command( "SEARCH.QUERY", "products", "{\"name\": \"wireless\"}", "LIMIT", "10", "OFFSET", "0", ) print(result) ``` ```go theme={"system"} package main import ( "context" "fmt" "os" "github.com/redis/go-redis/v9" ) func main() { opts, err := redis.ParseURL(os.Getenv("REDIS_URL")) if err != nil { panic(err) } client := redis.NewClient(opts) result, err := client.Do( context.Background(), "SEARCH.QUERY", "products", "{\"name\": \"wireless\"}", "LIMIT", "10", "OFFSET", "0", ).Result() if err != nil { panic(err) } fmt.Println(result) } ``` ```java theme={"system"} import java.net.URI; import redis.clients.jedis.Jedis; try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) { Object result = jedis.sendCommand( () -> "SEARCH.QUERY".getBytes(), "products", "{\"name\": \"wireless\"}", "LIMIT", "10", "OFFSET", "0" ); System.out.println(result); } ``` ```rust theme={"system"} fn main() -> redis::RedisResult<()> { let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set"); let client = redis::Client::open(url)?; let mut connection = client.get_connection()?; let mut command = redis::cmd("SEARCH.QUERY"); command.arg("products"); command.arg("{\"name\": \"wireless\"}"); command.arg("LIMIT"); command.arg("10"); command.arg("OFFSET"); command.arg("0"); let result: redis::Value = command.query(&mut connection)?; println!("{result:?}"); Ok(()) } ``` ```bash theme={"system"} curl -X POST https://YOUR_ENDPOINT.upstash.io \ -H "Authorization: Bearer $UPSTASH_REDIS_REST_TOKEN" \ -d '["SEARCH.QUERY", "products", "{\"name\": \"wireless\"}", "LIMIT", "10", "OFFSET", "0"]' ```