Executes a search query against an index on the node that receives the request. A node that does not index the target answers from the generation it last pulled, so a recently indexed document may not appear yet.
Path parameters
namestringrequired
Name of the index to search. To search one generation, add @ and the name of the generation, such as books@2.
Headers
X-Exofind-Freshnessany
A freshness token, for a request that carries none in its body. The body's freshness.atLeast is read when both are given.
Clauses that a matching document must satisfy. Clauses in the array are combined with an implicit AND. Evaluated clauses narrow all facet counts. If omitted, matches all documents.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
9 types
FieldClausetype: "field"
Matches documents by the value of a single field. The targeted field must be indexed for the requested matcher usage; if it is not configured for that usage, the request returns search:usage_unsupported.
Matches field values equal to any value in values. An empty array matches no documents.
Example
{
"type": "in",
"values": [
"fiction",
"poetry"
]
}
valuesany[]required
The values that a field value may equal.
AnyMatchertype: "any"
Matches any document that contains a value for the field.
Example
{
"type": "any"
}
PrefixMatchertype: "prefix"
Matches string field values starting with value, evaluated against the entire field value.
Example
{
"type": "prefix",
"value": "EX-"
}
valuestringrequired
The prefix that a field value must start with.
Example
"EX-"
UnderMatchertype: "under"
Matches values at or below the specified path in a hierarchical tree. Requires a field configured with hierarchy. Path segments must match complete levels, so Men/Sho matches nothing where a prefix matcher matches.
Example
{
"type": "under",
"path": "Men/Shoes"
}
pathstringrequired
Path in the hierarchical tree to match at or below.
Example
"Men/Shoes"
RangeMatchertype: "range"
Matches values within bounds. Accepts inclusive (gte, lte) and exclusive (gt, lt) bounds; either side may be left open, and at least one bound is required (search:matcher:range_empty).
Example
{
"type": "range",
"gte": 10,
"lt": 20
}
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
RangesMatchertype: "ranges"
Matches values falling within any of the specified range objects. An empty array matches no documents, matching the behavior of an empty in matcher.
Example
{
"type": "ranges",
"values": [
{
"gte": 10,
"lt": 20
},
{
"gte": 50
}
]
}
valuesMatcherRange[]required
The ranges to evaluate, each requiring at least one bound. A bucket returned by a range facet sets from as gte and to as lt.
Example
{
"gte": 10,
"lt": 20
}
4 properties
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
TextMatchertype: "text"
Matches text within a single field using field-level analysis.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply. Setting join with any other match returns search:clause:join_unsupported.
Typo tolerance handling. auto follows the field's typoTolerance configuration; off disables typo tolerance for the matcher.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Only applies to phrase queries or quoted phrases in user mode.
Whether parts of user text are read as filters on the fields of the index: auto reads a number typed next to the unit of a number field, or next to a comparative word such as under, as a filter on that field; off takes every word as text. Whatever was read is reported as interpreted beside the results. See Reading numbers and units.
Default
"auto"
Values
"auto", "off"
DistanceMatchertype: "distance"
Matches geopoint values within radius meters of the specified latitude and longitude coordinates.
Matches query text across one or more fields. Phrase queries operate within a single field and match terms exactly as typed, regardless of field typoTolerance. Fields defined only for autocomplete do not support phrase matching. See text.
Example
{
"type": "text",
"text": "silent spr",
"fields": {
"name": 3,
"description": null
}
}
textstringrequired
The query text to match.
Example
"silent spr"
fieldsmap of number
Object mapping field names to score weights. A field mapped to null uses the weight from its field definition. If omitted, searches all searchable fields, skipping autocomplete-only fields.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply, and a filter read out of the text is one of the parts. Setting join with any other match returns search:clause:join_unsupported. See Reading what was typed.
Typo tolerance handling. auto follows each field's typoTolerance configuration; off disables typo tolerance for the clause.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Setting slop above 0 with "match": "all" or "match": "any" returns search:clause:slop_unsupported.
Scope for multi-field term matching. term evaluates each term across all targeted fields, so terms may appear in different fields; field requires a single field to satisfy match on its own. Ignored by phrase queries.
Whether parts of user text are read as filters on the fields of the index, given as a mode or as the targets to read on. See Reading numbers and units.
Whether parts of user text are read as filters: auto reads a number typed next to a unit or a comparative word as a filter on the field declaring that unit, off takes every word as text.
Reads user text as filters on the named targets only. A number typed with a unit is read on every target declaring that unit; a number typed without one is read on every target holding a currency, when they all hold the same currency.
Clauses that must hold where the number is read: in the same value as the field for a field inside a nested list, and for the document otherwise. Takes what a nested clause takes: field, text, and, or, not and boost. A clause naming a field outside the list returns search:nested:field_not_inside.
Targets read instead, in order, where the document holds no value on this one - a product with no price on the customer's list is read on the store's list. Every target of the chain must declare the same unit; one in another unit returns search:interpret:fallback_unit_mismatch.
Matches the k nearest documents by vector distance in a specified field, scored by proximity. Cannot be combined with hits (search:hits:knn_unsupported).
Example
{
"type": "knn",
"field": "embedding",
"vector": [
0.1,
0.2
],
"k": 10,
"filter": [
{
"field": "published",
"match": {
"value": true
}
}
]
}
fieldstringrequired
The vector field to search.
Example
"embedding"
vectornumber[]required
The query vector. Its length must match the dimensions declared in the field definition.
Format
float
kintegerrequired
Number of nearest documents to return, at most EXOFIND_SEARCH_MAX_KNN_K.
Matches documents where a single element of a nestedobject field satisfies all child clauses. A nested clause on a flattened object field returns search:nested:path_not_nested; on a non-object field it returns an error. See nested.
Clauses evaluated within a single nested object value, naming fields by their dotted path. An empty array matches any document where the object field is present. May contain field, text, knn, and, or, not and boost; a clause that only means something for whole documents, such as another nested or a fuse, returns search:nested:clause_unsupported.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
scoreScore
Scoring mode for aggregating matching nested values. Only applies when scoring clauses exist within the nested clause.
Increases the relevance score of documents that satisfy child clauses without excluding non-matching documents.
Example
{
"type": "boost",
"weight": 2,
"clauses": [
{
"field": "featured",
"match": {
"value": true
}
}
]
}
weightnumberrequired
Multiplier applied to matching documents. Values greater than 1 increase score; values between 0 and 1 decrease score. Leaving it out, or setting it below 0 or to a non-finite number, returns search:clause:weight_out_of_range.
Matches documents across several rankings, scored and merged by rank. Documents are scored by the sum of weight / (rankConstant + rank) across the rankings that reached them. Because the clause reads only result positions, scores from different scales (such as BM25 text relevance and vector similarity) combine without normalization. Matches at most depth results per ranking. See fuse.
Clauses the ranking searches for, combined with an implicit AND. At least one clause is required.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
weightnumber
Multiplier that scales the ranking's contribution relative to other rankings. It cannot reorder results within the ranking.
Default
1
Format
float
depthinteger
Number of results read from each ranking. Pagination cannot exceed the merged list, similar to k in a knn clause. Must be at least 1, and at most EXOFIND_SEARCH_MAX_FUSE_DEPTH.
Default
100
Format
int32
rankConstantnumber
Constant added to each rank before it is inverted. Lower values increase the weight of the highest-ranked results in each ranking; higher values flatten the difference across ranks, giving more weight to documents found by multiple rankings. Must be above 0.
Clauses that narrow every ranking before it is cut to depth. A knn clause inside a ranking applies filter entries as a pre-filter, ensuring the vector ranking returns k results. Clauses placed beside the fuse clause filter the merged list after each ranking is cut to depth.
Refinement clauses, specified as field clauses or nested clauses. Filters narrow hits, but facets on the filtered field exclude their own filter entries from counts by default (see Facets). Unsupported clause types return search:filter:clause_unsupported. Clauses that score results return search:filter:scoring_unsupported.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
9 types
FieldClausetype: "field"
Matches documents by the value of a single field. The targeted field must be indexed for the requested matcher usage; if it is not configured for that usage, the request returns search:usage_unsupported.
Matches field values equal to any value in values. An empty array matches no documents.
Example
{
"type": "in",
"values": [
"fiction",
"poetry"
]
}
valuesany[]required
The values that a field value may equal.
AnyMatchertype: "any"
Matches any document that contains a value for the field.
Example
{
"type": "any"
}
PrefixMatchertype: "prefix"
Matches string field values starting with value, evaluated against the entire field value.
Example
{
"type": "prefix",
"value": "EX-"
}
valuestringrequired
The prefix that a field value must start with.
Example
"EX-"
UnderMatchertype: "under"
Matches values at or below the specified path in a hierarchical tree. Requires a field configured with hierarchy. Path segments must match complete levels, so Men/Sho matches nothing where a prefix matcher matches.
Example
{
"type": "under",
"path": "Men/Shoes"
}
pathstringrequired
Path in the hierarchical tree to match at or below.
Example
"Men/Shoes"
RangeMatchertype: "range"
Matches values within bounds. Accepts inclusive (gte, lte) and exclusive (gt, lt) bounds; either side may be left open, and at least one bound is required (search:matcher:range_empty).
Example
{
"type": "range",
"gte": 10,
"lt": 20
}
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
RangesMatchertype: "ranges"
Matches values falling within any of the specified range objects. An empty array matches no documents, matching the behavior of an empty in matcher.
Example
{
"type": "ranges",
"values": [
{
"gte": 10,
"lt": 20
},
{
"gte": 50
}
]
}
valuesMatcherRange[]required
The ranges to evaluate, each requiring at least one bound. A bucket returned by a range facet sets from as gte and to as lt.
Example
{
"gte": 10,
"lt": 20
}
4 properties
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
TextMatchertype: "text"
Matches text within a single field using field-level analysis.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply. Setting join with any other match returns search:clause:join_unsupported.
Typo tolerance handling. auto follows the field's typoTolerance configuration; off disables typo tolerance for the matcher.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Only applies to phrase queries or quoted phrases in user mode.
Whether parts of user text are read as filters on the fields of the index: auto reads a number typed next to the unit of a number field, or next to a comparative word such as under, as a filter on that field; off takes every word as text. Whatever was read is reported as interpreted beside the results. See Reading numbers and units.
Default
"auto"
Values
"auto", "off"
DistanceMatchertype: "distance"
Matches geopoint values within radius meters of the specified latitude and longitude coordinates.
Matches query text across one or more fields. Phrase queries operate within a single field and match terms exactly as typed, regardless of field typoTolerance. Fields defined only for autocomplete do not support phrase matching. See text.
Example
{
"type": "text",
"text": "silent spr",
"fields": {
"name": 3,
"description": null
}
}
textstringrequired
The query text to match.
Example
"silent spr"
fieldsmap of number
Object mapping field names to score weights. A field mapped to null uses the weight from its field definition. If omitted, searches all searchable fields, skipping autocomplete-only fields.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply, and a filter read out of the text is one of the parts. Setting join with any other match returns search:clause:join_unsupported. See Reading what was typed.
Typo tolerance handling. auto follows each field's typoTolerance configuration; off disables typo tolerance for the clause.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Setting slop above 0 with "match": "all" or "match": "any" returns search:clause:slop_unsupported.
Scope for multi-field term matching. term evaluates each term across all targeted fields, so terms may appear in different fields; field requires a single field to satisfy match on its own. Ignored by phrase queries.
Whether parts of user text are read as filters on the fields of the index, given as a mode or as the targets to read on. See Reading numbers and units.
Whether parts of user text are read as filters: auto reads a number typed next to a unit or a comparative word as a filter on the field declaring that unit, off takes every word as text.
Reads user text as filters on the named targets only. A number typed with a unit is read on every target declaring that unit; a number typed without one is read on every target holding a currency, when they all hold the same currency.
Clauses that must hold where the number is read: in the same value as the field for a field inside a nested list, and for the document otherwise. Takes what a nested clause takes: field, text, and, or, not and boost. A clause naming a field outside the list returns search:nested:field_not_inside.
Targets read instead, in order, where the document holds no value on this one - a product with no price on the customer's list is read on the store's list. Every target of the chain must declare the same unit; one in another unit returns search:interpret:fallback_unit_mismatch.
Matches the k nearest documents by vector distance in a specified field, scored by proximity. Cannot be combined with hits (search:hits:knn_unsupported).
Example
{
"type": "knn",
"field": "embedding",
"vector": [
0.1,
0.2
],
"k": 10,
"filter": [
{
"field": "published",
"match": {
"value": true
}
}
]
}
fieldstringrequired
The vector field to search.
Example
"embedding"
vectornumber[]required
The query vector. Its length must match the dimensions declared in the field definition.
Format
float
kintegerrequired
Number of nearest documents to return, at most EXOFIND_SEARCH_MAX_KNN_K.
Matches documents where a single element of a nestedobject field satisfies all child clauses. A nested clause on a flattened object field returns search:nested:path_not_nested; on a non-object field it returns an error. See nested.
Clauses evaluated within a single nested object value, naming fields by their dotted path. An empty array matches any document where the object field is present. May contain field, text, knn, and, or, not and boost; a clause that only means something for whole documents, such as another nested or a fuse, returns search:nested:clause_unsupported.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
scoreScore
Scoring mode for aggregating matching nested values. Only applies when scoring clauses exist within the nested clause.
Increases the relevance score of documents that satisfy child clauses without excluding non-matching documents.
Example
{
"type": "boost",
"weight": 2,
"clauses": [
{
"field": "featured",
"match": {
"value": true
}
}
]
}
weightnumberrequired
Multiplier applied to matching documents. Values greater than 1 increase score; values between 0 and 1 decrease score. Leaving it out, or setting it below 0 or to a non-finite number, returns search:clause:weight_out_of_range.
Matches documents across several rankings, scored and merged by rank. Documents are scored by the sum of weight / (rankConstant + rank) across the rankings that reached them. Because the clause reads only result positions, scores from different scales (such as BM25 text relevance and vector similarity) combine without normalization. Matches at most depth results per ranking. See fuse.
Clauses the ranking searches for, combined with an implicit AND. At least one clause is required.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
weightnumber
Multiplier that scales the ranking's contribution relative to other rankings. It cannot reorder results within the ranking.
Default
1
Format
float
depthinteger
Number of results read from each ranking. Pagination cannot exceed the merged list, similar to k in a knn clause. Must be at least 1, and at most EXOFIND_SEARCH_MAX_FUSE_DEPTH.
Default
100
Format
int32
rankConstantnumber
Constant added to each rank before it is inverted. Lower values increase the weight of the highest-ranked results in each ranking; higher values flatten the difference across ranks, giving more weight to documents found by multiple rankings. Must be above 0.
Clauses that narrow every ranking before it is cut to depth. A knn clause inside a ranking applies filter entries as a pre-filter, ensuring the vector ranking returns k results. Clauses placed beside the fuse clause filter the merged list after each ranking is cut to depth.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
facetsFacetRequest[]
Fields to aggregate match counts for. See Facets. If omitted, no facet counts are calculated.
Example
{
"field": "category",
"limit": 20,
"order": "count"
}
8 properties
namestring
Key used for the facet in the response. Required when faceting on the same field multiple times. Duplicate facet names return search:facet:name_duplicate. Defaults to the field name.
fieldstringrequired
Target field to aggregate.
Example
"category"
limitinteger
Maximum number of facet values to return, at most EXOFIND_SEARCH_MAX_FACET_VALUES.
Sort order of facet values: "count" (descending by count), "value" (ascending by value), or "declared" (the order the search settings declare for the field's values, followed by every other value by count).
Default
"count"
Values
"count", "value", "declared"
rangesFacetRange[]
Array of range bucket definitions. See Range buckets. Cannot be combined with limit or order (search:facet:ranges_conflicting).
Example
{
"from": 100,
"to": 200
}
2 properties
fromany
The lowest value the bucket holds, itself included. Omit for no lower end.
Example
100
toany
Where the bucket ends, itself not included. Omit for no upper end.
Example
200
pathstring
Starting path level for hierarchical fields. See Counting down a tree. Defaults to the root.
depthinteger
Number of hierarchical levels below path to count.
Default
1
Format
int32
Range
1 to 10
excludeFiltersstring[]
List of field paths whose filter entries are excluded from this facet's calculation. Defaults to the facet's own field path. An empty array [] disables filter exclusion. A blank path returns search:facet:exclude_filters_invalid.
Order in which results are returned. If omitted, results are sorted by relevance score in descending order.
Example
{
"field": "name",
"order": "asc"
}
3 types
FieldSorttype: "field"
Sorts by field value. The target field must have sorting enabled. A field inside a nestedobject is named by its dotted path, and only the nested values that the query's nested clauses matched are considered.
Sorts by distance from the specified geographic coordinate, nearest first. Accepts no order property. A distance sort on a nested object field returns search:sort:nested_unsupported.
Example
{
"type": "distance",
"field": "location",
"lat": 59.3,
"lon": 18.1
}
fieldstringrequired
Target geopoint field, as named in the index definition.
Example
"location"
latnumberrequired
Latitude of the origin, in degrees.
Format
double
Range
-90 to 90
Example
59.3
lonnumberrequired
Longitude of the origin, in degrees.
Format
double
Range
-180 to 180
Example
18.1
localestring
BCP-47 locale tag used to read and return locale-specific fields. Matches the closest declared locale on each field (for example, sv-SE falls back to sv). If no matching variant exists, uses the field default.
Example
"sv"
fieldsstring[]
Document fields to return with each result. Fields inside an object are specified by dotted path and returned nested inside the object. Requesting unretrievable fields returns an error (see Document source). The primary key is always included.
highlightHighlight
Fields to return highlighted snippets for. See Highlighting.
Example
{
"fields": {
"name": {},
"description": {
"fragments": 2
}
}
}
1 property
fieldsmap of HighlightFieldrequired
Fields to return fragments for, keyed by the name the field has in the index definition. An empty options object asks for the defaults. Fields must have highlighting enabled (matching or autocomplete); requesting an unconfigured field returns search:usage_unsupported.
1 property
<key>HighlightField
Configuration for highlighting text fragments in a single field.
Example
{
"fragments": 2,
"length": 150,
"pre": "<mark>",
"post": "</mark>"
}
4 properties
fragmentsinteger
Maximum number of fragments to return.
Default
3
Format
int32
lengthinteger
Target character length per fragment. Fragments break on sentence boundaries, and text shorter than this comes back as a single fragment holding all of it.
Default
150
Format
int32
Range
1 to 10000
prestring
Prefix tag inserted before highlighted terms. May be empty.
Default
"<em>"
poststring
Postfix tag inserted after highlighted terms. May be empty.
Default
"</em>"
matchedMatched
Nested object fields for which to return matched values with each hit. See Matched values.
Example
{
"fields": {
"variants": {
"limit": 3
}
}
}
1 property
fieldsmap of MatchedFieldrequired
Object fields to answer for, keyed by the name the field has in the index definition. An empty options object asks for the defaults. Targeting a field that is not a nested object returns search:matched:field_not_nested.
1 property
<key>MatchedField
Configuration for returning matched values of a nested object field.
Example
{
"limit": 3,
"fields": [
"variants.color"
]
}
2 properties
limitinteger
Maximum number of matched values to return per hit. How many matched in all always comes back beside them.
Default
3
Format
int32
Range
1 to 100
fieldsstring[]
Field paths inside the nested object to include in each returned value, defaulting to all of them. Paths must reside under the target object path (search:matched:field_not_inside) and exist in the schema (search:field_unknown). On an index whose source is none, a named field has to be stored (search:usage_unsupported).
hitsHits
Specifies an object field whose matched values return as individual hits instead of full documents. See What a hit stands for.
Example
{
"path": "variants",
"fields": [
"variants.color",
"variants.price"
]
}
3 properties
pathstringrequired
Dotted path of the nested object field whose matched values become hits. Targeting a field that is not a nested object returns search:hits:path_not_nested.
Example
"variants"
fieldsstring[]
Dotted field paths inside the nested object to return in value, defaulting to all of them. Names must be prefixed by path (search:hits:field_not_inside) and exist in the index (search:field_unknown). On an index whose source is none, a named field has to be stored (search:usage_unsupported).
Clauses deciding which documents expand into value hits; every other matching document stays a document hit. Combined with an implicit AND, and specified as field or nested clauses. If omitted, every matching document expands. Unsupported clause types return search:hits:when_clause_unsupported; clauses that score return search:hits:when_scoring_unsupported. Sorting by a field is refused while this is set (search:hits:when_sort_unsupported).
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
9 types
FieldClausetype: "field"
Matches documents by the value of a single field. The targeted field must be indexed for the requested matcher usage; if it is not configured for that usage, the request returns search:usage_unsupported.
Matches field values equal to any value in values. An empty array matches no documents.
Example
{
"type": "in",
"values": [
"fiction",
"poetry"
]
}
valuesany[]required
The values that a field value may equal.
AnyMatchertype: "any"
Matches any document that contains a value for the field.
Example
{
"type": "any"
}
PrefixMatchertype: "prefix"
Matches string field values starting with value, evaluated against the entire field value.
Example
{
"type": "prefix",
"value": "EX-"
}
valuestringrequired
The prefix that a field value must start with.
Example
"EX-"
UnderMatchertype: "under"
Matches values at or below the specified path in a hierarchical tree. Requires a field configured with hierarchy. Path segments must match complete levels, so Men/Sho matches nothing where a prefix matcher matches.
Example
{
"type": "under",
"path": "Men/Shoes"
}
pathstringrequired
Path in the hierarchical tree to match at or below.
Example
"Men/Shoes"
RangeMatchertype: "range"
Matches values within bounds. Accepts inclusive (gte, lte) and exclusive (gt, lt) bounds; either side may be left open, and at least one bound is required (search:matcher:range_empty).
Example
{
"type": "range",
"gte": 10,
"lt": 20
}
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
RangesMatchertype: "ranges"
Matches values falling within any of the specified range objects. An empty array matches no documents, matching the behavior of an empty in matcher.
Example
{
"type": "ranges",
"values": [
{
"gte": 10,
"lt": 20
},
{
"gte": 50
}
]
}
valuesMatcherRange[]required
The ranges to evaluate, each requiring at least one bound. A bucket returned by a range facet sets from as gte and to as lt.
Example
{
"gte": 10,
"lt": 20
}
TextMatchertype: "text"
Matches text within a single field using field-level analysis.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply. Setting join with any other match returns search:clause:join_unsupported.
Typo tolerance handling. auto follows the field's typoTolerance configuration; off disables typo tolerance for the matcher.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Only applies to phrase queries or quoted phrases in user mode.
Whether parts of user text are read as filters on the fields of the index: auto reads a number typed next to the unit of a number field, or next to a comparative word such as under, as a filter on that field; off takes every word as text. Whatever was read is reported as interpreted beside the results. See Reading numbers and units.
Default
"auto"
Values
"auto", "off"
DistanceMatchertype: "distance"
Matches geopoint values within radius meters of the specified latitude and longitude coordinates.
Matches query text across one or more fields. Phrase queries operate within a single field and match terms exactly as typed, regardless of field typoTolerance. Fields defined only for autocomplete do not support phrase matching. See text.
Example
{
"type": "text",
"text": "silent spr",
"fields": {
"name": 3,
"description": null
}
}
textstringrequired
The query text to match.
Example
"silent spr"
fieldsmap of number
Object mapping field names to score weights. A field mapped to null uses the weight from its field definition. If omitted, searches all searchable fields, skipping autocomplete-only fields.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply, and a filter read out of the text is one of the parts. Setting join with any other match returns search:clause:join_unsupported. See Reading what was typed.
Typo tolerance handling. auto follows each field's typoTolerance configuration; off disables typo tolerance for the clause.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Setting slop above 0 with "match": "all" or "match": "any" returns search:clause:slop_unsupported.
Scope for multi-field term matching. term evaluates each term across all targeted fields, so terms may appear in different fields; field requires a single field to satisfy match on its own. Ignored by phrase queries.
Whether parts of user text are read as filters on the fields of the index, given as a mode or as the targets to read on. See Reading numbers and units.
Whether parts of user text are read as filters: auto reads a number typed next to a unit or a comparative word as a filter on the field declaring that unit, off takes every word as text.
Reads user text as filters on the named targets only. A number typed with a unit is read on every target declaring that unit; a number typed without one is read on every target holding a currency, when they all hold the same currency.
Matches the k nearest documents by vector distance in a specified field, scored by proximity. Cannot be combined with hits (search:hits:knn_unsupported).
Example
{
"type": "knn",
"field": "embedding",
"vector": [
0.1,
0.2
],
"k": 10,
"filter": [
{
"field": "published",
"match": {
"value": true
}
}
]
}
fieldstringrequired
The vector field to search.
Example
"embedding"
vectornumber[]required
The query vector. Its length must match the dimensions declared in the field definition.
Format
float
kintegerrequired
Number of nearest documents to return, at most EXOFIND_SEARCH_MAX_KNN_K.
Matches documents where a single element of a nestedobject field satisfies all child clauses. A nested clause on a flattened object field returns search:nested:path_not_nested; on a non-object field it returns an error. See nested.
Clauses evaluated within a single nested object value, naming fields by their dotted path. An empty array matches any document where the object field is present. May contain field, text, knn, and, or, not and boost; a clause that only means something for whole documents, such as another nested or a fuse, returns search:nested:clause_unsupported.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
scoreScore
Scoring mode for aggregating matching nested values. Only applies when scoring clauses exist within the nested clause.
Increases the relevance score of documents that satisfy child clauses without excluding non-matching documents.
Example
{
"type": "boost",
"weight": 2,
"clauses": [
{
"field": "featured",
"match": {
"value": true
}
}
]
}
weightnumberrequired
Multiplier applied to matching documents. Values greater than 1 increase score; values between 0 and 1 decrease score. Leaving it out, or setting it below 0 or to a non-finite number, returns search:clause:weight_out_of_range.
Matches documents across several rankings, scored and merged by rank. Documents are scored by the sum of weight / (rankConstant + rank) across the rankings that reached them. Because the clause reads only result positions, scores from different scales (such as BM25 text relevance and vector similarity) combine without normalization. Matches at most depth results per ranking. See fuse.
Clauses the ranking searches for, combined with an implicit AND. At least one clause is required.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
weightnumber
Multiplier that scales the ranking's contribution relative to other rankings. It cannot reorder results within the ranking.
Default
1
Format
float
depthinteger
Number of results read from each ranking. Pagination cannot exceed the merged list, similar to k in a knn clause. Must be at least 1, and at most EXOFIND_SEARCH_MAX_FUSE_DEPTH.
Default
100
Format
int32
rankConstantnumber
Constant added to each rank before it is inverted. Lower values increase the weight of the highest-ranked results in each ranking; higher values flatten the difference across ranks, giving more weight to documents found by multiple rankings. Must be above 0.
Clauses that narrow every ranking before it is cut to depth. A knn clause inside a ranking applies filter entries as a pre-filter, ensuring the vector ranking returns k results. Clauses placed beside the fuse clause filter the merged list after each ranking is cut to depth.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
limitinteger
Maximum number of results to return, at most EXOFIND_SEARCH_MAX_LIMIT. Setting limit to 0 returns the total match count without hits.
Default
10
Format
int32
offsetinteger
Number of matching results to skip. Specify at most one of offset, after, or before.
Default
0
Format
int32
afterstring
Cursor string from the next property of a previous response to fetch the next page.
beforestring
Cursor string from the previous property of a previous response to fetch the preceding page.
pagesPagesRequest
Requests numbered page metadata. Accepts an optional { "max": n } object to limit the number of page entries (default 9). Implies "total": "exact".
Example
{
"max": 9
}
1 property
maxinteger
Maximum number of page entries to return.
Default
9
Format
int32
totalTotalMode
Counting mode for the total matching document count: "estimate" counts until exceeding the returned window; "exact" counts every matching document.
Document ranking signals used to adjust relevance scoring. Added to the signals configured on the index unless signalsMode says otherwise. See Signals. If omitted, uses the ranking signals configured on the index.
Example
{
"field": "purchases",
"saturation": {
"pivot": 50
},
"weight": 0.5
}
5 properties
fieldstringrequired
Field to read the value from, as named in the index definition. Must be a numeric or timestamp field with sorting enabled.
Example
"purchases"
saturationSaturation
Ranks by how far the value rises above a pivot. For number fields.
Example
{
"pivot": 50
}
1 property
pivotnumberrequired
The value that counts for half of what the signal can give. Must be above zero.
Format
double
Example
50
decayDecay
Ranks by how long ago the value was. For timestamp fields.
Example
{
"halfLife": 604800
}
1 property
halfLifeintegerrequired
How many seconds it takes for the signal to be worth half as much. Must be above zero.
Format
int64
Example
604800
linearLinear
Ranks by how far the value is toward a ceiling, as value / ceiling held between 0 and 1. For number fields holding a score computed elsewhere.
Example
{
"ceiling": 1
}
1 property
ceilingnumberrequired
The value that counts for all of what the signal can give. Must be above zero.
Format
double
Example
1
weightnumber
How much the signal can lift a document at most, as a share of its score.
Default
1
Format
float
signalsModeSignalsMode
How signals meets the ranking configured on the index: "add" ranks by both, with a signal here standing in for one on the same field; "replace" ranks by signals alone. Supplying this without signals returns search:signal:mode_without_signals.
Default
"add"
Values
"add", "replace"
rescoreRescore
Reorders the best results of a search in a second pass without changing which documents matched. See Rescoring.
Example
{
"window": 200,
"boost": [
{
"field": "brand",
"match": {
"value": "adidas"
}
}
],
"signals": [
{
"field": "purchases",
"saturation": {
"pivot": 50
}
}
],
"weight": 0.5
}
4 properties
windowintegerrequired
Number of best results to score a second time. Must be at least offset plus limit, and at most EXOFIND_SEARCH_MAX_RESCORE_WINDOW.
Clauses that lift results satisfying them. Clauses do not filter or narrow search hits; a result that satisfies none of them keeps its first-pass score. Wrap a clause in boost to weigh it against the others.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
9 types
FieldClausetype: "field"
Matches documents by the value of a single field. The targeted field must be indexed for the requested matcher usage; if it is not configured for that usage, the request returns search:usage_unsupported.
Matches field values equal to any value in values. An empty array matches no documents.
Example
{
"type": "in",
"values": [
"fiction",
"poetry"
]
}
valuesany[]required
The values that a field value may equal.
AnyMatchertype: "any"
Matches any document that contains a value for the field.
Example
{
"type": "any"
}
PrefixMatchertype: "prefix"
Matches string field values starting with value, evaluated against the entire field value.
Example
{
"type": "prefix",
"value": "EX-"
}
valuestringrequired
The prefix that a field value must start with.
Example
"EX-"
UnderMatchertype: "under"
Matches values at or below the specified path in a hierarchical tree. Requires a field configured with hierarchy. Path segments must match complete levels, so Men/Sho matches nothing where a prefix matcher matches.
Example
{
"type": "under",
"path": "Men/Shoes"
}
pathstringrequired
Path in the hierarchical tree to match at or below.
Example
"Men/Shoes"
RangeMatchertype: "range"
Matches values within bounds. Accepts inclusive (gte, lte) and exclusive (gt, lt) bounds; either side may be left open, and at least one bound is required (search:matcher:range_empty).
Example
{
"type": "range",
"gte": 10,
"lt": 20
}
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
RangesMatchertype: "ranges"
Matches values falling within any of the specified range objects. An empty array matches no documents, matching the behavior of an empty in matcher.
Example
{
"type": "ranges",
"values": [
{
"gte": 10,
"lt": 20
},
{
"gte": 50
}
]
}
valuesMatcherRange[]required
The ranges to evaluate, each requiring at least one bound. A bucket returned by a range facet sets from as gte and to as lt.
Example
{
"gte": 10,
"lt": 20
}
TextMatchertype: "text"
Matches text within a single field using field-level analysis.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply. Setting join with any other match returns search:clause:join_unsupported.
Typo tolerance handling. auto follows the field's typoTolerance configuration; off disables typo tolerance for the matcher.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Only applies to phrase queries or quoted phrases in user mode.
Whether parts of user text are read as filters on the fields of the index: auto reads a number typed next to the unit of a number field, or next to a comparative word such as under, as a filter on that field; off takes every word as text. Whatever was read is reported as interpreted beside the results. See Reading numbers and units.
Default
"auto"
Values
"auto", "off"
DistanceMatchertype: "distance"
Matches geopoint values within radius meters of the specified latitude and longitude coordinates.
Matches query text across one or more fields. Phrase queries operate within a single field and match terms exactly as typed, regardless of field typoTolerance. Fields defined only for autocomplete do not support phrase matching. See text.
Example
{
"type": "text",
"text": "silent spr",
"fields": {
"name": 3,
"description": null
}
}
textstringrequired
The query text to match.
Example
"silent spr"
fieldsmap of number
Object mapping field names to score weights. A field mapped to null uses the weight from its field definition. If omitted, searches all searchable fields, skipping autocomplete-only fields.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply, and a filter read out of the text is one of the parts. Setting join with any other match returns search:clause:join_unsupported. See Reading what was typed.
Typo tolerance handling. auto follows each field's typoTolerance configuration; off disables typo tolerance for the clause.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Setting slop above 0 with "match": "all" or "match": "any" returns search:clause:slop_unsupported.
Scope for multi-field term matching. term evaluates each term across all targeted fields, so terms may appear in different fields; field requires a single field to satisfy match on its own. Ignored by phrase queries.
Whether parts of user text are read as filters on the fields of the index, given as a mode or as the targets to read on. See Reading numbers and units.
Whether parts of user text are read as filters: auto reads a number typed next to a unit or a comparative word as a filter on the field declaring that unit, off takes every word as text.
Reads user text as filters on the named targets only. A number typed with a unit is read on every target declaring that unit; a number typed without one is read on every target holding a currency, when they all hold the same currency.
Matches the k nearest documents by vector distance in a specified field, scored by proximity. Cannot be combined with hits (search:hits:knn_unsupported).
Example
{
"type": "knn",
"field": "embedding",
"vector": [
0.1,
0.2
],
"k": 10,
"filter": [
{
"field": "published",
"match": {
"value": true
}
}
]
}
fieldstringrequired
The vector field to search.
Example
"embedding"
vectornumber[]required
The query vector. Its length must match the dimensions declared in the field definition.
Format
float
kintegerrequired
Number of nearest documents to return, at most EXOFIND_SEARCH_MAX_KNN_K.
Matches documents where a single element of a nestedobject field satisfies all child clauses. A nested clause on a flattened object field returns search:nested:path_not_nested; on a non-object field it returns an error. See nested.
Clauses evaluated within a single nested object value, naming fields by their dotted path. An empty array matches any document where the object field is present. May contain field, text, knn, and, or, not and boost; a clause that only means something for whole documents, such as another nested or a fuse, returns search:nested:clause_unsupported.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
scoreScore
Scoring mode for aggregating matching nested values. Only applies when scoring clauses exist within the nested clause.
Increases the relevance score of documents that satisfy child clauses without excluding non-matching documents.
Example
{
"type": "boost",
"weight": 2,
"clauses": [
{
"field": "featured",
"match": {
"value": true
}
}
]
}
weightnumberrequired
Multiplier applied to matching documents. Values greater than 1 increase score; values between 0 and 1 decrease score. Leaving it out, or setting it below 0 or to a non-finite number, returns search:clause:weight_out_of_range.
Matches documents across several rankings, scored and merged by rank. Documents are scored by the sum of weight / (rankConstant + rank) across the rankings that reached them. Because the clause reads only result positions, scores from different scales (such as BM25 text relevance and vector similarity) combine without normalization. Matches at most depth results per ranking. See fuse.
Clauses the ranking searches for, combined with an implicit AND. At least one clause is required.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
weightnumber
Multiplier that scales the ranking's contribution relative to other rankings. It cannot reorder results within the ranking.
Default
1
Format
float
depthinteger
Number of results read from each ranking. Pagination cannot exceed the merged list, similar to k in a knn clause. Must be at least 1, and at most EXOFIND_SEARCH_MAX_FUSE_DEPTH.
Default
100
Format
int32
rankConstantnumber
Constant added to each rank before it is inverted. Lower values increase the weight of the highest-ranked results in each ranking; higher values flatten the difference across ranks, giving more weight to documents found by multiple rankings. Must be above 0.
Clauses that narrow every ranking before it is cut to depth. A knn clause inside a ranking applies filter entries as a pre-filter, ensuring the vector ranking returns k results. Clauses placed beside the fuse clause filter the merged list after each ranking is cut to depth.
Document values taken into the second score, written the same way as top-level signals. Applied to every result in the window. The ranking configured on the index belongs to the first pass and is not applied again here, so signalsMode does not affect these.
Example
{
"field": "purchases",
"saturation": {
"pivot": 50
},
"weight": 0.5
}
5 properties
fieldstringrequired
Field to read the value from, as named in the index definition. Must be a numeric or timestamp field with sorting enabled.
Example
"purchases"
saturationSaturation
Ranks by how far the value rises above a pivot. For number fields.
Example
{
"pivot": 50
}
1 property
pivotnumberrequired
The value that counts for half of what the signal can give. Must be above zero.
Format
double
Example
50
decayDecay
Ranks by how long ago the value was. For timestamp fields.
Example
{
"halfLife": 604800
}
1 property
halfLifeintegerrequired
How many seconds it takes for the signal to be worth half as much. Must be above zero.
Format
int64
Example
604800
linearLinear
Ranks by how far the value is toward a ceiling, as value / ceiling held between 0 and 1. For number fields holding a score computed elsewhere.
Example
{
"ceiling": 1
}
1 property
ceilingnumberrequired
The value that counts for all of what the signal can give. Must be above zero.
Format
double
Example
1
weightnumber
How much the signal can lift a document at most, as a share of its score.
Default
1
Format
float
weightnumber
Multiplier applied to the second-pass score before adding it to the first-pass score.
What the request demands of the state it is answered from. Omit it to be answered from what the node holds. See Freshness.
1 property
atLeaststring
A freshness token that an earlier response returned in its freshness property or X-Exofind-Freshness header. The node answers only once it holds the state the token describes: the generation, the commit and the search settings. A node that is behind commits, pulls or reads the settings first, and answers search:freshness:unavailable with a Retry-After header when it has waited EXOFIND_SEARCH_FRESHNESS_WAIT without reaching the state. The token is opaque; pass it back unchanged.
Example
"AQoIcHJvZHVjdHMSATIYBw"
Responses
200
The matching documents, in the order that sort asks for.
The matching hits, in the order that sort asked for.
Example
{
"id": "9781234567890",
"score": 8.42,
"document": {
"name": "Silent Spring",
"price": 12.5
},
"highlights": {
"name": [
"Silent <em>Spring</em>"
]
}
}
8 properties
idany
Primary key of the document, omitted on an index that has none. A value hit carries the key of the document holding it, so several hits share an id when several values of one document matched - the identity of such a hit is id together with key, or with index on a field that declares no key.
Example
9781234567890
indexinteger
Zero-based position of the value this hit stands for in the parent document's value array. Present only when the search asked for value hits. A reindex is free to reorder values, so this names the same value only for as long as the document is not written again - key is what does not move.
Format
int32
keystring
What the value this hit stands for reads for the key its object field declares. Two values of one document never read the same, so id and key name one value and go on naming it after a reindex. Omitted for a document hit, for a field that declares no key, and on an index whose source is none when the key's field is not stored.
scorenumber
How well the hit matched. Omitted when the search computed no scores, rather than defaulted to something that looks like a value: a search of plain filters carrying no ranking signal and no rescore is ordered by nothing a score could say. A value hit scores what its document scored plus what the value itself scored under the nested clauses of its path.
Format
float
Example
8.42
valueobject
The matched nested value object, keyed by field name. Present only when the search requests value hits. On an index whose source is none it holds the value's stored fields, and is omitted when nothing of the value is stored.
documentobject
Selected fields of the document per the search request fields property, keyed by field name and shaped as indexed. A field declared multiple is an array, and a locale-specific field is an object holding the single variant read for the query locale. For a value hit, returns the fields of the parent document.
highlightsmap of string[]
Highlighted fragments keyed by field name. Present when highlighting is requested, omitting fields with no matching text in the hit - for a value hit the fragments are cut from the hit's own value. Omitted when highlighting is not requested.
1 property
<key>string[]
matchedmap of MatchedValues
Matched nested values keyed by field name, with one entry per requested field. Omitted when matched values are not requested.
1 property
<key>MatchedValues
Matched values of a nested object field for a hit.
Example
{
"values": [
{
"color": "red",
"price": 18
},
{
"color": "blue",
"price": 19.5
}
],
"totalValues": 5
}
2 properties
valuesany[]
Array of matched nested values, each keyed by field name, up to limit. If scoring clauses exist within the nested clause, values are ordered by score; otherwise, they appear in document order. On an index whose source is none each value holds its stored fields, and the array is omitted when nothing of the values is stored.
totalValuesinteger
Total count of matched values for the nested field in the document. Exceeds the number of entries under values when the limit is reached.
Format
int32
totalTotal
How many hits matched in total, counted in whatever the search answers with: a document that expanded into values counts once per value.
Example
{
"count": 128,
"exact": true
}
2 properties
countinteger
Total number of matching results.
Format
int64
Example
128
exactboolean
Whether count is exact or a lower bound. Always true when "total": "exact" is requested or when calculating facets.
documentsTotal
How many documents matched, which is what the facets are counted in. Present only for a search whose hits names a when, where some documents expand into values and the rest do not; omitted otherwise, where it would be the same number as total. A document that when expands with no matching value under path counts here while answering with no hit.
Example
{
"count": 128,
"exact": true
}
2 properties
countinteger
Total number of matching results.
Format
int64
Example
128
exactboolean
Whether count is exact or a lower bound. Always true when "total": "exact" is requested or when calculating facets.
facetsmap of FacetResult
Facet results keyed by facet name. Omitted entirely when the request asked for no facets.
1 property
<key>FacetResult
Match counts for one faceted field. Counting per value returns values with totalValues; counting into ranges returns buckets, omitting the other representation. Facet counts exclude filter entries on the facet's own field by default.
Array of facet value objects, in the requested order and limited to the configured maximum.
Example
{
"value": "fiction",
"count": 87,
"label": "Fiction"
}
6 properties
valueany
The facet value in its stored format: a string, boolean, number, or ISO 8601 timestamp string. For a hierarchical field, returns the label of the current level.
Example
"fiction"
countinteger
Number of matching documents containing this value.
Format
int64
Example
87
labelstring
The label the search settings of the index declare for the value, in the locale of the search, falling back to the field's default locale. Omitted when the settings declare no label for the value. See Field settings.
Example
"Fiction"
pathstring
The full path to the level, used in under filter matchers. Omitted for non-hierarchical fields.
Child hierarchy levels with their counts, evaluated up to depth levels below the current path. Omitted at the maximum counted depth and for non-hierarchical fields.
Example
{
"value": "fiction",
"count": 87,
"label": "Fiction"
}
totalValuesinteger
Total count of distinct child values below this level. Counts values, not documents. Exceeds the number of entries under values when the limit is reached, and no count covers the values left out. Omitted for non-hierarchical fields.
Format
int32
totalValuesinteger
Total count of distinct values matching the query. Counts values, not documents. Exceeds the number of entries under values when the limit is reached, and no count covers the values left out.
Format
int32
bucketsFacetBucket[]
Array of range bucket objects with match counts, in the requested order.
Example
{
"from": 100,
"to": 200,
"count": 17
}
3 properties
fromany
Inclusive lower bound of the range bucket, as specified in the request. Omitted for open-ended ranges.
Example
100
toany
Exclusive upper bound of the range bucket, as specified in the request. Omitted for open-ended ranges.
Example
200
countinteger
Number of matching documents with values falling within the range bucket.
Format
int64
Example
17
pagePage
Where in the results this window sits, and how to move from it.
Example
{
"limit": 20,
"offset": 0,
"next": "AWtaPJHiAAAS1QFmQErhSA"
}
5 properties
limitinteger
Maximum number of results returned in the page window.
Format
int32
Example
20
offsetinteger
Number of matching results skipped before the window. Omitted when navigating with next or previous cursors. Cursors encode positions rather than count offsets and are not restricted by EXOFIND_SEARCH_MAX_PAGE_DEPTH.
Format
int32
previousstring
Cursor for the preceding window, passed in before. Omitted on the first window of a search paged by offset. A window reached by a cursor carries it whenever the window is full, which says there may be results before it rather than that there are, so following it can answer an empty window.
nextstring
Cursor for the next window, passed in after. Omitted on the final window of a search paged by offset. A window reached by a cursor carries it whenever the window is full, which says there may be results after it rather than that there are, so following it can answer an empty window. A cursor is an opaque token. Pass it back as it arrived, and do not read anything out of it.
pagesPagesResult
Numbered page metadata, present when requested.
Example
{
"count": 7,
"next": {
"number": 4,
"cursor": "AW9aPJHiAAAAPA"
},
"start": [
{
"number": 1,
"cursor": "AW9aPJHiAAAAAA"
},
{
"number": 2,
"cursor": "AW9aPJHiAAAAFA"
},
{
"number": 3,
"cursor": "AW9aPJHiAAAAKA",
"current": true
}
],
"end": [
{
"number": 7,
"cursor": "AW9aPJHiAAAAeA"
}
]
}
6 properties
countinteger
Total number of pages.
Format
int64
Example
7
previousPageRef
Metadata for the page preceding the current page. Omitted on the first page.
Example
{
"number": 3,
"cursor": "AW9aPJHiAAAAKA",
"current": true
}
3 properties
numberinteger
1-based page number.
Format
int64
Example
3
cursorstring
Cursor that fetches the page, passed in after.
currentboolean
True for the current page; omitted on all other pages.
nextPageRef
Metadata for the page following the current page. Omitted on the final page and when the page exceeds maximum page depth.
Example
{
"number": 3,
"cursor": "AW9aPJHiAAAAKA",
"current": true
}
3 properties
numberinteger
1-based page number.
Format
int64
Example
3
cursorstring
Cursor that fetches the page, passed in after.
currentboolean
True for the current page; omitted on all other pages.
startPageRef[]
Page entries at the start of the list.
Example
{
"number": 3,
"cursor": "AW9aPJHiAAAAKA",
"current": true
}
3 properties
numberinteger
1-based page number.
Format
int64
Example
3
cursorstring
Cursor that fetches the page, passed in after.
currentboolean
True for the current page; omitted on all other pages.
middlePageRef[]
Page entries surrounding the current page, present when they touch neither end of the list.
Example
{
"number": 3,
"cursor": "AW9aPJHiAAAAKA",
"current": true
}
3 properties
numberinteger
1-based page number.
Format
int64
Example
3
cursorstring
Cursor that fetches the page, passed in after.
currentboolean
True for the current page; omitted on all other pages.
endPageRef[]
Page entries at the end of the list. Omitted when the final page exceeds maximum page depth.
Example
{
"number": 3,
"cursor": "AW9aPJHiAAAAKA",
"current": true
}
3 properties
numberinteger
1-based page number.
Format
int64
Example
3
cursorstring
Cursor that fetches the page, passed in after.
currentboolean
True for the current page; omitted on all other pages.
What the search let go of to find anything. Omitted entirely when the query was not relaxed, so its presence always means the results answer less than what was asked for.
Example
{
"dropped": [
{
"word": "waterproof",
"reason": "unmatched"
}
],
"text": "running shoes"
}
2 properties
droppedDropped[]
List of dropped words and the reason each was removed, in the order they appeared in the query.
Example
{
"word": "waterproof",
"reason": "unmatched"
}
2 properties
wordstring
The word as it was typed.
Example
"waterproof"
reasonReason
Reason the word was dropped.
Values
"unmatched", "common"
textstring
The effective query string used to execute the search.
What the search read out of the query text as filters, and the text that was left. Omitted entirely when nothing was read. See Reading numbers and units.
Example
{
"filters": [
{
"field": "price",
"match": {
"type": "range",
"lt": 500
},
"words": [
"under",
"500"
]
}
],
"text": "shoes"
}
2 properties
filtersFilter[]
The filters that were read, in the order their words were typed. Two fields declaring the same unit read the same words as two filters, either of which a document may satisfy.
Clauses that hold where the filter is read, as the when of the target the request named. Absent when the filter is read wherever the field holds a value.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
9 types
FieldClausetype: "field"
Matches documents by the value of a single field. The targeted field must be indexed for the requested matcher usage; if it is not configured for that usage, the request returns search:usage_unsupported.
Matches field values equal to any value in values. An empty array matches no documents.
Example
{
"type": "in",
"values": [
"fiction",
"poetry"
]
}
valuesany[]required
The values that a field value may equal.
AnyMatchertype: "any"
Matches any document that contains a value for the field.
Example
{
"type": "any"
}
PrefixMatchertype: "prefix"
Matches string field values starting with value, evaluated against the entire field value.
Example
{
"type": "prefix",
"value": "EX-"
}
valuestringrequired
The prefix that a field value must start with.
Example
"EX-"
UnderMatchertype: "under"
Matches values at or below the specified path in a hierarchical tree. Requires a field configured with hierarchy. Path segments must match complete levels, so Men/Sho matches nothing where a prefix matcher matches.
Example
{
"type": "under",
"path": "Men/Shoes"
}
pathstringrequired
Path in the hierarchical tree to match at or below.
Example
"Men/Shoes"
RangeMatchertype: "range"
Matches values within bounds. Accepts inclusive (gte, lte) and exclusive (gt, lt) bounds; either side may be left open, and at least one bound is required (search:matcher:range_empty).
Example
{
"type": "range",
"gte": 10,
"lt": 20
}
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
RangesMatchertype: "ranges"
Matches values falling within any of the specified range objects. An empty array matches no documents, matching the behavior of an empty in matcher.
Example
{
"type": "ranges",
"values": [
{
"gte": 10,
"lt": 20
},
{
"gte": 50
}
]
}
valuesMatcherRange[]required
The ranges to evaluate, each requiring at least one bound. A bucket returned by a range facet sets from as gte and to as lt.
Example
{
"gte": 10,
"lt": 20
}
TextMatchertype: "text"
Matches text within a single field using field-level analysis.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply. Setting join with any other match returns search:clause:join_unsupported.
Typo tolerance handling. auto follows the field's typoTolerance configuration; off disables typo tolerance for the matcher.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Only applies to phrase queries or quoted phrases in user mode.
Whether parts of user text are read as filters on the fields of the index: auto reads a number typed next to the unit of a number field, or next to a comparative word such as under, as a filter on that field; off takes every word as text. Whatever was read is reported as interpreted beside the results. See Reading numbers and units.
Default
"auto"
Values
"auto", "off"
DistanceMatchertype: "distance"
Matches geopoint values within radius meters of the specified latitude and longitude coordinates.
Matches query text across one or more fields. Phrase queries operate within a single field and match terms exactly as typed, regardless of field typoTolerance. Fields defined only for autocomplete do not support phrase matching. See text.
Example
{
"type": "text",
"text": "silent spr",
"fields": {
"name": 3,
"description": null
}
}
textstringrequired
The query text to match.
Example
"silent spr"
fieldsmap of number
Object mapping field names to score weights. A field mapped to null uses the weight from its field definition. If omitted, searches all searchable fields, skipping autocomplete-only fields.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply, and a filter read out of the text is one of the parts. Setting join with any other match returns search:clause:join_unsupported. See Reading what was typed.
Typo tolerance handling. auto follows each field's typoTolerance configuration; off disables typo tolerance for the clause.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Setting slop above 0 with "match": "all" or "match": "any" returns search:clause:slop_unsupported.
Scope for multi-field term matching. term evaluates each term across all targeted fields, so terms may appear in different fields; field requires a single field to satisfy match on its own. Ignored by phrase queries.
Whether parts of user text are read as filters on the fields of the index, given as a mode or as the targets to read on. See Reading numbers and units.
Whether parts of user text are read as filters: auto reads a number typed next to a unit or a comparative word as a filter on the field declaring that unit, off takes every word as text.
Reads user text as filters on the named targets only. A number typed with a unit is read on every target declaring that unit; a number typed without one is read on every target holding a currency, when they all hold the same currency.
Matches the k nearest documents by vector distance in a specified field, scored by proximity. Cannot be combined with hits (search:hits:knn_unsupported).
Example
{
"type": "knn",
"field": "embedding",
"vector": [
0.1,
0.2
],
"k": 10,
"filter": [
{
"field": "published",
"match": {
"value": true
}
}
]
}
fieldstringrequired
The vector field to search.
Example
"embedding"
vectornumber[]required
The query vector. Its length must match the dimensions declared in the field definition.
Format
float
kintegerrequired
Number of nearest documents to return, at most EXOFIND_SEARCH_MAX_KNN_K.
Matches documents where a single element of a nestedobject field satisfies all child clauses. A nested clause on a flattened object field returns search:nested:path_not_nested; on a non-object field it returns an error. See nested.
Clauses evaluated within a single nested object value, naming fields by their dotted path. An empty array matches any document where the object field is present. May contain field, text, knn, and, or, not and boost; a clause that only means something for whole documents, such as another nested or a fuse, returns search:nested:clause_unsupported.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
scoreScore
Scoring mode for aggregating matching nested values. Only applies when scoring clauses exist within the nested clause.
Increases the relevance score of documents that satisfy child clauses without excluding non-matching documents.
Example
{
"type": "boost",
"weight": 2,
"clauses": [
{
"field": "featured",
"match": {
"value": true
}
}
]
}
weightnumberrequired
Multiplier applied to matching documents. Values greater than 1 increase score; values between 0 and 1 decrease score. Leaving it out, or setting it below 0 or to a non-finite number, returns search:clause:weight_out_of_range.
Matches documents across several rankings, scored and merged by rank. Documents are scored by the sum of weight / (rankConstant + rank) across the rankings that reached them. Because the clause reads only result positions, scores from different scales (such as BM25 text relevance and vector similarity) combine without normalization. Matches at most depth results per ranking. See fuse.
Clauses the ranking searches for, combined with an implicit AND. At least one clause is required.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
weightnumber
Multiplier that scales the ranking's contribution relative to other rankings. It cannot reorder results within the ranking.
Default
1
Format
float
depthinteger
Number of results read from each ranking. Pagination cannot exceed the merged list, similar to k in a knn clause. Must be at least 1, and at most EXOFIND_SEARCH_MAX_FUSE_DEPTH.
Default
100
Format
int32
rankConstantnumber
Constant added to each rank before it is inverted. Lower values increase the weight of the highest-ranked results in each ranking; higher values flatten the difference across ranks, giving more weight to documents found by multiple rankings. Must be above 0.
Clauses that narrow every ranking before it is cut to depth. A knn clause inside a ranking applies filter entries as a pre-filter, ensuring the vector ranking returns k results. Clauses placed beside the fuse clause filter the merged list after each ranking is cut to depth.
What the values of the field have to satisfy, in the shape the match of a field clause takes: a range for a bound, an equals for a number written with its unit and nothing else. Can be sent back as a filter as it is.
Example
{
"value": "fiction"
}
9 types
EqualsMatchertype: "equals"
Matches field values equal to value.
Example
{
"value": "fiction"
}
valueanyrequired
The value that the field value must equal.
Example
"fiction"
InMatchertype: "in"
Matches field values equal to any value in values. An empty array matches no documents.
Example
{
"type": "in",
"values": [
"fiction",
"poetry"
]
}
valuesany[]required
The values that a field value may equal.
AnyMatchertype: "any"
Matches any document that contains a value for the field.
Example
{
"type": "any"
}
PrefixMatchertype: "prefix"
Matches string field values starting with value, evaluated against the entire field value.
Example
{
"type": "prefix",
"value": "EX-"
}
valuestringrequired
The prefix that a field value must start with.
Example
"EX-"
UnderMatchertype: "under"
Matches values at or below the specified path in a hierarchical tree. Requires a field configured with hierarchy. Path segments must match complete levels, so Men/Sho matches nothing where a prefix matcher matches.
Example
{
"type": "under",
"path": "Men/Shoes"
}
pathstringrequired
Path in the hierarchical tree to match at or below.
Example
"Men/Shoes"
RangeMatchertype: "range"
Matches values within bounds. Accepts inclusive (gte, lte) and exclusive (gt, lt) bounds; either side may be left open, and at least one bound is required (search:matcher:range_empty).
Example
{
"type": "range",
"gte": 10,
"lt": 20
}
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
RangesMatchertype: "ranges"
Matches values falling within any of the specified range objects. An empty array matches no documents, matching the behavior of an empty in matcher.
Example
{
"type": "ranges",
"values": [
{
"gte": 10,
"lt": 20
},
{
"gte": 50
}
]
}
valuesMatcherRange[]required
The ranges to evaluate, each requiring at least one bound. A bucket returned by a range facet sets from as gte and to as lt.
Example
{
"gte": 10,
"lt": 20
}
4 properties
gteany
Lower bound, the value itself included.
Example
10
gtany
Lower bound, the value itself excluded.
lteany
Upper bound, the value itself included.
ltany
Upper bound, exclusive.
Example
20
TextMatchertype: "text"
Matches text within a single field using field-level analysis.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply. Setting join with any other match returns search:clause:join_unsupported.
Typo tolerance handling. auto follows the field's typoTolerance configuration; off disables typo tolerance for the matcher.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Only applies to phrase queries or quoted phrases in user mode.
Whether parts of user text are read as filters on the fields of the index: auto reads a number typed next to the unit of a number field, or next to a comparative word such as under, as a filter on that field; off takes every word as text. Whatever was read is reported as interpreted beside the results. See Reading numbers and units.
Default
"auto"
Values
"auto", "off"
DistanceMatchertype: "distance"
Matches geopoint values within radius meters of the specified latitude and longitude coordinates.
Example
{
"type": "distance",
"lat": 59.3,
"lon": 18.1,
"radius": 5000
}
latnumberrequired
Latitude of the origin, in degrees.
Format
double
Range
-90 to 90
Example
59.3
lonnumberrequired
Longitude of the origin, in degrees.
Format
double
Range
-180 to 180
Example
18.1
radiusnumberrequired
Maximum distance from the origin in meters.
Format
double
Example
5000
wordsstring[]
The words the filter was read from, as they were typed and in the order they were typed.
The targets read instead where a document holds no value on the field, in order, as the fallback of the target the request named. Absent when there are none.
Clauses that must hold where the number is read: in the same value as the field for a field inside a nested list, and for the document otherwise. Takes what a nested clause takes: field, text, and, or, not and boost. A clause naming a field outside the list returns search:nested:field_not_inside.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
9 types
FieldClausetype: "field"
Matches documents by the value of a single field. The targeted field must be indexed for the requested matcher usage; if it is not configured for that usage, the request returns search:usage_unsupported.
Matches query text across one or more fields. Phrase queries operate within a single field and match terms exactly as typed, regardless of field typoTolerance. Fields defined only for autocomplete do not support phrase matching. See text.
Example
{
"type": "text",
"text": "silent spr",
"fields": {
"name": 3,
"description": null
}
}
textstringrequired
The query text to match.
Example
"silent spr"
fieldsmap of number
Object mapping field names to score weights. A field mapped to null uses the weight from its field definition. If omitted, searches all searchable fields, skipping autocomplete-only fields.
How the parts of user text combine: all requires every word and every quoted phrase, any accepts a document that holds one of them. Excluded terms (-word) always apply, and a filter read out of the text is one of the parts. Setting join with any other match returns search:clause:join_unsupported. See Reading what was typed.
Typo tolerance handling. auto follows each field's typoTolerance configuration; off disables typo tolerance for the clause.
Default
"auto"
Values
"auto", "off"
slopinteger
Number of intervening words permitted between terms in a phrase, without changing their relative order. Setting slop above 0 with "match": "all" or "match": "any" returns search:clause:slop_unsupported.
Scope for multi-field term matching. term evaluates each term across all targeted fields, so terms may appear in different fields; field requires a single field to satisfy match on its own. Ignored by phrase queries.
Whether parts of user text are read as filters on the fields of the index, given as a mode or as the targets to read on. See Reading numbers and units.
Matches the k nearest documents by vector distance in a specified field, scored by proximity. Cannot be combined with hits (search:hits:knn_unsupported).
Example
{
"type": "knn",
"field": "embedding",
"vector": [
0.1,
0.2
],
"k": 10,
"filter": [
{
"field": "published",
"match": {
"value": true
}
}
]
}
fieldstringrequired
The vector field to search.
Example
"embedding"
vectornumber[]required
The query vector. Its length must match the dimensions declared in the field definition.
Format
float
kintegerrequired
Number of nearest documents to return, at most EXOFIND_SEARCH_MAX_KNN_K.
Matches documents where a single element of a nestedobject field satisfies all child clauses. A nested clause on a flattened object field returns search:nested:path_not_nested; on a non-object field it returns an error. See nested.
Clauses evaluated within a single nested object value, naming fields by their dotted path. An empty array matches any document where the object field is present. May contain field, text, knn, and, or, not and boost; a clause that only means something for whole documents, such as another nested or a fuse, returns search:nested:clause_unsupported.
Example
{
"field": "category",
"match": {
"value": "fiction"
}
}
scoreScore
Scoring mode for aggregating matching nested values. Only applies when scoring clauses exist within the nested clause.
Increases the relevance score of documents that satisfy child clauses without excluding non-matching documents.
Example
{
"type": "boost",
"weight": 2,
"clauses": [
{
"field": "featured",
"match": {
"value": true
}
}
]
}
weightnumberrequired
Multiplier applied to matching documents. Values greater than 1 increase score; values between 0 and 1 decrease score. Leaving it out, or setting it below 0 or to a non-finite number, returns search:clause:weight_out_of_range.
Matches documents across several rankings, scored and merged by rank. Documents are scored by the sum of weight / (rankConstant + rank) across the rankings that reached them. Because the clause reads only result positions, scores from different scales (such as BM25 text relevance and vector similarity) combine without normalization. Matches at most depth results per ranking. See fuse.
Rankings to run and merge. Specifying fewer than two rankings returns search:clause:rankings_too_few.
Example
{
"clauses": [
{
"type": "text",
"text": "waterproof jacket",
"fields": {
"name": null
}
}
],
"weight": 0.5
}
depthinteger
Number of results read from each ranking. Pagination cannot exceed the merged list, similar to k in a knn clause. Must be at least 1, and at most EXOFIND_SEARCH_MAX_FUSE_DEPTH.
Default
100
Format
int32
rankConstantnumber
Constant added to each rank before it is inverted. Lower values increase the weight of the highest-ranked results in each ranking; higher values flatten the difference across ranks, giving more weight to documents found by multiple rankings. Must be above 0.
Clauses that narrow every ranking before it is cut to depth. A knn clause inside a ranking applies filter entries as a pre-filter, ensuring the vector ranking returns k results. Clauses placed beside the fuse clause filter the merged list after each ranking is cut to depth.
Targets read instead, in order, where the document holds no value on this one - a product with no price on the customer's list is read on the store's list. Every target of the chain must declare the same unit; one in another unit returns search:interpret:fallback_unit_mismatch.
Example
{
"field": "prices.amount",
"when": [
{
"field": "prices.list",
"match": {
"value": "customer"
}
}
],
"fallback": [
{
"field": "prices.amount",
"when": [
{
"field": "prices.list",
"match": {
"value": "store"
}
}
]
}
]
}
textstring
The text that was left once the words of the filters were taken out. Empty when everything typed was read.
Example
"shoes"
generationstring
Name of the generation that answered. A request that names the index answers from the generation that is live when it arrives, so add @ and this name to the index name to send a later request to the same data. See Names and generations.
Example
"2"
freshnessstring
A freshness token for the state the answer came from: the generation, its commit, and the version of the search settings. Pass it as freshness.atLeast on a later request, and that request is answered from this state or a later one whichever node it lands on. Opaque; pass it back unchanged. See Freshness.
Example
"AQoIcHJvZHVjdHMSATIYBw"
tookMsnumber
Execution time for the search request in milliseconds, including fractions of one.
Format
double
Example
7.412
400
The request is not a valid search, or it asks for more than the node allows. See Search configuration for the caps.
ErrorResponse
The body of every failed request. Error codes use colon-separated namespaces such as index:field:name_invalid, are stable across API versions, and are never renamed or reused, so clients match on code rather than on message. See Errors.
codestring
Identifies the failure type. For validation failures, this is validation and the individual problems are listed in errors. For all other failures, this matches the code of the single entry in errors.
Example
"validation"
messagestring
Human-readable message for log output. Match on code rather than on message. When a validation failure contains one problem, this is that problem's message. When it contains several, it reads Request contains N errors.
All problems found in the request. A validation failure reports every field with a problem, so a caller can fix them in one pass rather than one request at a time.
"message": "Field `id` is marked as a primary key and multiple, primary keys can not have multiple values",
"path": "id"
}
4 properties
codestring
The error code identifying this specific problem.
Example
"index:field:primary_key:multiple_unsupported"
messagestring
Human-readable description of this problem.
Example
"Field `id` is marked as a primary key and multiple, primary keys can not have multiple values"
pathstring
Location of the offending value in the request, such as fields.title or documents[1].nonexistent. Names join with ., one element of a list reads [n] counted from zero, and a key of a free-form map such as metadata goes in brackets and double quotes when it holds a dot or a bracket, as metadata["build.sha"]. A field inside an object field carries its own dotted path, so a path here reaches a field the same way a query does. Omitted when the problem applies to the request as a whole. See API conventions.
Example
"id"
argumentsmap of string
The values the message was rendered with, so a client can render a message of its own from the code.
A cursor was taken under this `sort` but does not name a position in it, which a `sort` field that changed type in the index definition leaves behind. Start the search again from the first page.
The freshness token was issued in a format version this node does not read. The `version` argument carries it; send the request to a node of the release that issued the token.
The freshness token is of another index than the one in the path. The `index` argument carries the index the token is of.
401
The request carries no credential this node accepts. Absent, malformed, unknown and lapsed keys are all answered alike, so a refusal cannot be used to find out which keys exist. The response carries WWW-Authenticate: Bearer.
ErrorResponse
The body of every failed request. Error codes use colon-separated namespaces such as index:field:name_invalid, are stable across API versions, and are never renamed or reused, so clients match on code rather than on message. See Errors.
codestring
Identifies the failure type. For validation failures, this is validation and the individual problems are listed in errors. For all other failures, this matches the code of the single entry in errors.
Example
"validation"
messagestring
Human-readable message for log output. Match on code rather than on message. When a validation failure contains one problem, this is that problem's message. When it contains several, it reads Request contains N errors.
All problems found in the request. A validation failure reports every field with a problem, so a caller can fix them in one pass rather than one request at a time.
"message": "Field `id` is marked as a primary key and multiple, primary keys can not have multiple values",
"path": "id"
}
4 properties
codestring
The error code identifying this specific problem.
Example
"index:field:primary_key:multiple_unsupported"
messagestring
Human-readable description of this problem.
Example
"Field `id` is marked as a primary key and multiple, primary keys can not have multiple values"
pathstring
Location of the offending value in the request, such as fields.title or documents[1].nonexistent. Names join with ., one element of a list reads [n] counted from zero, and a key of a free-form map such as metadata goes in brackets and double quotes when it holds a dot or a bracket, as metadata["build.sha"]. A field inside an object field carries its own dotted path, so a path here reaches a field the same way a query does. Omitted when the problem applies to the request as a whole. See API conventions.
Example
"id"
argumentsmap of string
The values the message was rendered with, so a client can render a message of its own from the code.
The request carries no credential this node accepts.
403
The API key does not have the search permission.
ErrorResponse
The body of every failed request. Error codes use colon-separated namespaces such as index:field:name_invalid, are stable across API versions, and are never renamed or reused, so clients match on code rather than on message. See Errors.
codestring
Identifies the failure type. For validation failures, this is validation and the individual problems are listed in errors. For all other failures, this matches the code of the single entry in errors.
Example
"validation"
messagestring
Human-readable message for log output. Match on code rather than on message. When a validation failure contains one problem, this is that problem's message. When it contains several, it reads Request contains N errors.
All problems found in the request. A validation failure reports every field with a problem, so a caller can fix them in one pass rather than one request at a time.
"message": "Field `id` is marked as a primary key and multiple, primary keys can not have multiple values",
"path": "id"
}
4 properties
codestring
The error code identifying this specific problem.
Example
"index:field:primary_key:multiple_unsupported"
messagestring
Human-readable description of this problem.
Example
"Field `id` is marked as a primary key and multiple, primary keys can not have multiple values"
pathstring
Location of the offending value in the request, such as fields.title or documents[1].nonexistent. Names join with ., one element of a list reads [n] counted from zero, and a key of a free-form map such as metadata goes in brackets and double quotes when it holds a dot or a bracket, as metadata["build.sha"]. A field inside an object field carries its own dotted path, so a path here reaches a field the same way a query does. Omitted when the problem applies to the request as a whole. See API conventions.
Example
"id"
argumentsmap of string
The values the message was rendered with, so a client can render a message of its own from the code.
The key is accepted but does not hold the `search` permission.
404
The index does not exist, or the key has no permissions on it. An index on which a key has no permissions returns this status as though it did not exist.
ErrorResponse
The body of every failed request. Error codes use colon-separated namespaces such as index:field:name_invalid, are stable across API versions, and are never renamed or reused, so clients match on code rather than on message. See Errors.
codestring
Identifies the failure type. For validation failures, this is validation and the individual problems are listed in errors. For all other failures, this matches the code of the single entry in errors.
Example
"validation"
messagestring
Human-readable message for log output. Match on code rather than on message. When a validation failure contains one problem, this is that problem's message. When it contains several, it reads Request contains N errors.
All problems found in the request. A validation failure reports every field with a problem, so a caller can fix them in one pass rather than one request at a time.
"message": "Field `id` is marked as a primary key and multiple, primary keys can not have multiple values",
"path": "id"
}
4 properties
codestring
The error code identifying this specific problem.
Example
"index:field:primary_key:multiple_unsupported"
messagestring
Human-readable description of this problem.
Example
"Field `id` is marked as a primary key and multiple, primary keys can not have multiple values"
pathstring
Location of the offending value in the request, such as fields.title or documents[1].nonexistent. Names join with ., one element of a list reads [n] counted from zero, and a key of a free-form map such as metadata goes in brackets and double quotes when it holds a dot or a bracket, as metadata["build.sha"]. A field inside an object field carries its own dotted path, so a path here reaches a field the same way a query does. Omitted when the problem applies to the request as a whole. See API conventions.
Example
"id"
argumentsmap of string
The values the message was rendered with, so a client can render a message of its own from the code.
The node holds no such index, or the key has no permission on it.
409
The index cannot be searched right now.
ErrorResponse
The body of every failed request. Error codes use colon-separated namespaces such as index:field:name_invalid, are stable across API versions, and are never renamed or reused, so clients match on code rather than on message. See Errors.
codestring
Identifies the failure type. For validation failures, this is validation and the individual problems are listed in errors. For all other failures, this matches the code of the single entry in errors.
Example
"validation"
messagestring
Human-readable message for log output. Match on code rather than on message. When a validation failure contains one problem, this is that problem's message. When it contains several, it reads Request contains N errors.
All problems found in the request. A validation failure reports every field with a problem, so a caller can fix them in one pass rather than one request at a time.
"message": "Field `id` is marked as a primary key and multiple, primary keys can not have multiple values",
"path": "id"
}
4 properties
codestring
The error code identifying this specific problem.
Example
"index:field:primary_key:multiple_unsupported"
messagestring
Human-readable description of this problem.
Example
"Field `id` is marked as a primary key and multiple, primary keys can not have multiple values"
pathstring
Location of the offending value in the request, such as fields.title or documents[1].nonexistent. Names join with ., one element of a list reads [n] counted from zero, and a key of a free-form map such as metadata goes in brackets and double quotes when it holds a dot or a bracket, as metadata["build.sha"]. A field inside an object field carries its own dotted path, so a path here reaches a field the same way a query does. Omitted when the problem applies to the request as a whole. See API conventions.
Example
"id"
argumentsmap of string
The values the message was rendered with, so a client can render a message of its own from the code.
The index has no live generation. Promote one and send the request again.
503
The search did not finish on the node.
ErrorResponse
The body of every failed request. Error codes use colon-separated namespaces such as index:field:name_invalid, are stable across API versions, and are never renamed or reused, so clients match on code rather than on message. See Errors.
codestring
Identifies the failure type. For validation failures, this is validation and the individual problems are listed in errors. For all other failures, this matches the code of the single entry in errors.
Example
"validation"
messagestring
Human-readable message for log output. Match on code rather than on message. When a validation failure contains one problem, this is that problem's message. When it contains several, it reads Request contains N errors.
All problems found in the request. A validation failure reports every field with a problem, so a caller can fix them in one pass rather than one request at a time.
"message": "Field `id` is marked as a primary key and multiple, primary keys can not have multiple values",
"path": "id"
}
4 properties
codestring
The error code identifying this specific problem.
Example
"index:field:primary_key:multiple_unsupported"
messagestring
Human-readable description of this problem.
Example
"Field `id` is marked as a primary key and multiple, primary keys can not have multiple values"
pathstring
Location of the offending value in the request, such as fields.title or documents[1].nonexistent. Names join with ., one element of a list reads [n] counted from zero, and a key of a free-form map such as metadata goes in brackets and double quotes when it holds a dot or a bracket, as metadata["build.sha"]. A field inside an object field carries its own dotted path, so a path here reaches a field the same way a query does. Omitted when the problem applies to the request as a whole. See API conventions.
Example
"id"
argumentsmap of string
The values the message was rendered with, so a client can render a message of its own from the code.
The node did not reach the state the freshness token asks for within `EXOFIND_SEARCH_FRESHNESS_WAIT`. Send the request again after the `Retry-After` header.
Served to a request carrying no credential where the node sets an anonymous key.
An API key sent as a bearer token, such as Authorization: Bearer exok_4ff6b760264c1918_ePQcdT1O9HSATZoXfDbT8hhHGsP9VpZH. A key carries grants that pair permissions with index patterns; the permission each endpoint needs is named beside it. Nodes running with EXOFIND_AUTH_MODE=none accept requests without a credential, and a node with EXOFIND_AUTH_ANONYMOUS_KEY set serves requests that carry none with the permissions of that key.
Exofind is built by Level Four AB and is available under the Apache License 2.0.