---
title: "Delete Document(s) by Request Object"
method: DELETE
path: "/api/v1/index/{index_id}/doc"
tags: ["Document"]
---

# Delete Document(s) by Request Object

`DELETE /api/v1/index/{index_id}/doc`

Delete document by document_id, by array of document_id (bulk), by query (SearchRequestObject) from index with index_id, or clear all documents from index.
Immediately effective, independent of commit.
Index space used by deleted documents is not reclaimed (until compaction is implemented), but result_count_total is updated.
By manually deleting the delete.bin file the deleted documents can be recovered (until compaction).
Deleted documents impact performance, especially but not limited to counting (Count, TopKCount). They also increase the size of the index (until compaction is implemented).
For minimal query latency delete index and reindexing documents is preferred over deleting documents (until compaction is implemented).
BM25 scores are not updated (until compaction is implemented), but the impact is minimal.
Document ID can by obtained by search. When deleting by query (SearchRequestObject), it is advised to perform a dry run search first, to see which documents will be deleted.

## Path parameters

- `index_id` integer, required

## Headers

- `apikey` string, required

## Request body

- SearchRequestObject — Search request object
  - `query` string, required — Query string, search operators + - "" are recognized.
  - `query_vector` unknown
  - `enable_empty_query` boolean — Enable empty query: if true, an empty query string iterates through all indexed documents, supporting the query parameters: offset, length, query_facets, facet_filter, result_sort, otherwise an empty query string returns no results. Typical use cases include index browsing, index export, conversion, analytics, audits, and inspection.
  - `offset` integer — Offset of search results to return.
  - `length` integer — Number of search results to return.
  - `result_type` 'Count' | 'Topk' | 'TopkCount' — The following result types are supported: - **Count** (count all results that match the query, but returning top-k results is not required) - **Topk** (returns the top-k results per query, but counting all results that match the query is not required) - **TopkCount** (returns the top-k results per query + count all results that match the query)
  - `realtime` boolean — True realtime search: include indexed, but uncommitted documents into search results.
  - `highlights` Highlight[] — Specify field names where to create keyword-in-context fragments and highlight query terms.
    - `field` string, required — Specifies the field from which the fragments (snippets, summaries) are created.
    - `name` string — Allows to specifiy multiple highlight result fields from the same source field, leaving the original field intact, Default: if name is empty then field is used instead, i.e the original field is overwritten with the highlight.
    - `fragment_number` integer — If 0/default then return the full original text without fragmenting.
    - `fragment_size` integer — Specifies the length of a highlight fragment. The default 0 returns the full original text without truncating, but still with highlighting if highlight_markup is enabled.
    - `highlight_markup` boolean — if true, the matching query terms within the fragments are highlighted with HTML markup **\<b\>term\<\/b\>**.
    - `pre_tags` string — Specifies the markup tags to insert **before** each highlighted term (e.g. \"\<b\>\" or \"\<em\>\"). This can be any string, but is most often an HTML or XML tag. Only used when **highlight_markup** is set to true.
    - `post_tags` string — Specifies the markup tags to insert **after** each highlighted term. (e.g. \"\<\/b\>\" or \"\<\/em\>\"). This can be any string, but is most often an HTML or XML tag. Only used when **highlight_markup** is set to true.
  - `field_filter` string[] — Specify field names where to search at querytime, whereas SchemaField.indexed is set at indextime. If empty then all indexed fields are searched.
  - `fields` string[] — Specify names of fields to return in the search results, where SchemaField.store is set at indextime. If empty then all stored fields are returned.
  - `distance_fields` DistanceField[] — Specify distance fields to derive at query time and return in the search results.
    - `field` string, required — field name of a numeric facet field (currently onyl Point field type supported)
    - `distance` string, required — field name of the distance field we are deriving from the numeric facet field (Point type) and the base (Point type)
    - `base` number[], required
    - `unit` 'Kilometers' | 'Miles', required — DistanceUnit defines the unit for distance calculation: kilometers or miles.
  - `query_facets` QueryFacet[] — Facets to return with search results: if empty then no facets are returned. Facets are only enabled on facet fields that are defined in schema at create_index!
    - union — Defines the query facets: - string facet field values - range segments for numerical facet field values
      - object — Range segment definition for numerical facet field values of type u8
        - `U8` object, required — Range segment definition for numerical facet field values of type u8
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type u16
        - `U16` object, required — Range segment definition for numerical facet field values of type u16
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type u32
        - `U32` object, required — Range segment definition for numerical facet field values of type u32
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type u64
        - `U64` object, required — Range segment definition for numerical facet field values of type u64
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type i8
        - `I8` object, required — Range segment definition for numerical facet field values of type i8
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type i16
        - `I16` object, required — Range segment definition for numerical facet field values of type i16
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type i32
        - `I32` object, required — Range segment definition for numerical facet field values of type i32
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type i64
        - `I64` object, required — Range segment definition for numerical facet field values of type i64
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type Unix timestamp
        - `Timestamp` object, required — Range segment definition for numerical facet field values of type Unix timestamp
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type f32
        - `F32` object, required — Range segment definition for numerical facet field values of type f32
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Range segment definition for numerical facet field values of type f64
        - `F64` object, required — Range segment definition for numerical facet field values of type f64
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
      - object — Facet field values of type string
        - `String16` object, required — Facet field values of type string
          - `field` string, required — field name
          - `prefix` string, required — Prefix filter of facet values to return
          - `length` integer, required — maximum number of facet values to return
      - object — Facet field values of type string
        - `String32` object, required — Facet field values of type string
          - `field` string, required — field name
          - `prefix` string, required — Prefix filter of facet values to return
          - `length` integer, required — maximum number of facet values to return
      - object — Facet field values of type string set
        - `StringSet16` object, required — Facet field values of type string set
          - `field` string, required — field name
          - `prefix` string, required — Prefix filter of facet values to return
          - `length` integer, required — maximum number of facet values to return
      - object — Facet field values of type string set
        - `StringSet32` object, required — Facet field values of type string set
          - `field` string, required — field name
          - `prefix` string, required — Prefix filter of facet values to return
          - `length` integer, required — maximum number of facet values to return
      - object — Range segment definition for numerical facet field values of type Point (distance between base of type Point and facet field of type Point)
        - `Point` object, required — Range segment definition for numerical facet field values of type Point (distance between base of type Point and facet field of type Point)
          - `field` string, required — field name
          - `range_type` 'CountWithinRange' | 'CountAboveRange' | 'CountBelowRange', required — Create query_list and non_unique_query_list blockwise intersection : if the corresponding blocks with a 65k docid range for each term have at least a single docid, then the intersect_docid within a single block is executed (=segments?) specifies how to count the frequency of numerical facet field values
          - `ranges` array[], required — range label, range start
            - unknown[]
              - …
          - `base` number[], required
          - `unit` 'Kilometers' | 'Miles', required — DistanceUnit defines the unit for distance calculation: kilometers or miles.
      - 'None' — No query facet
  - `facet_filter` FacetFilter[] — Facet filters to filter search results by facet values: if empty then no facet filters are applied. Facet filters are only enabled on facet fields that are defined in schema at create_index!
    - union — FacetFilter: either numerical range facet filter (range start/end) or string facet filter (vector of strings) at least one (boolean OR) must match.
      - object — U8 range filter
        - `U8` object, required — U8 range filter
          - `field` string, required — field name
          - `filter` RangeU8, required — U8 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — U16 range filter
        - `U16` object, required — U16 range filter
          - `field` string, required — field name
          - `filter` RangeU16, required — U16 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — U32 range filter
        - `U32` object, required — U32 range filter
          - `field` string, required — field name
          - `filter` RangeU32, required — U32 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — U64 range filter
        - `U64` object, required — U64 range filter
          - `field` string, required — field name
          - `filter` RangeU64, required — U64 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — I8 range filter
        - `I8` object, required — I8 range filter
          - `field` string, required — field name
          - `filter` RangeI8, required — I8 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — I16 range filter
        - `I16` object, required — I16 range filter
          - `field` string, required — field name
          - `filter` RangeI16, required — I16 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — I32 range filter
        - `I32` object, required — I32 range filter
          - `field` string, required — field name
          - `filter` RangeI32, required — I32 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — I64 range filter
        - `I64` object, required — I64 range filter
          - `field` string, required — field name
          - `filter` RangeI64, required — I64 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — Timestamp range filter, Unix timestamp: the number of seconds since 1 January 1970
        - `Timestamp` object, required — Timestamp range filter, Unix timestamp: the number of seconds since 1 January 1970
          - `field` string, required — field name
          - `filter` RangeI64, required — I64 range filter
            - `start` integer, required — range start
            - `end` integer, required — range end
      - object — F32 range filter
        - `F32` object, required — F32 range filter
          - `field` string, required — field name
          - `filter` RangeF32, required — F32 range filter
            - `start` number, float, required — range start
            - `end` number, float, required — range end
      - object — F64 range filter
        - `F64` object, required — F64 range filter
          - `field` string, required — field name
          - `filter` RangeF64, required — F64 range filter
            - `start` number, double, required — range start
            - `end` number, double, required — range end
      - object — String16 filter
        - `String16` object, required — String16 filter
          - `field` string, required — field name
          - `filter` string[], required — filter: array of facet string values
      - object — StringSet16 filter
        - `StringSet16` object, required — StringSet16 filter
          - `field` string, required — field name
          - `filter` string[], required — filter: array of facet string values
      - object — String32 filter
        - `String32` object, required — String32 filter
          - `field` string, required — field name
          - `filter` string[], required — filter: array of facet string values
      - object — StringSet32 filter
        - `StringSet32` object, required — StringSet32 filter
          - `field` string, required — field name
          - `filter` string[], required — filter: array of facet string values
      - object — Point proximity range filter
        - `Point` object, required — Point proximity range filter
          - `field` string, required — field name
          - `filter` unknown[], required — filter: base point (latitude/lat, longitude/lon), proximity range start, proximity range end, distance unit
            - unknown
  - `result_sort` ResultSort[] — Sort field and order: Search results are sorted by the specified facet field, either in ascending or descending order. If no sort field is specified, then the search results are sorted by rank in descending order per default. Multiple sort fields are combined by a "sort by, then sort by"-method ("tie-breaking"-algorithm). The results are sorted by the first field, and only for those results where the first field value is identical (tie) the results are sub-sorted by the second field, until the n-th field value is either not equal or the last field is reached. A special _score field (BM25x), reflecting how relevant the result is for a given search query (phrase match, match in title etc.) can be combined with any of the other sort fields as primary, secondary or n-th search criterium. Sort is only enabled on facet fields that are defined in schema at create_index! Examples: - result_sort = vec![ResultSort {field: "price".into(), order: SortOrder::Descending, base: FacetValue::None},ResultSort {field: "language".into(), order: SortOrder::Ascending, base: FacetValue::None}]; - result_sort = vec![ResultSort {field: "location".into(),order: SortOrder::Ascending, base: FacetValue::Point(vec![38.8951, -77.0364])}];
    - `field` string, required — name of the facet field to sort by
    - `order` 'Ascending' | 'Descending', required — Specifies the sort order for the search results.
    - `base` union, required — FacetValue: Facet field value types
      - object — Boolean value
        - `Bool` boolean, required — Boolean value
      - object — Unsigned 8-bit integer
        - `U8` integer, required — Unsigned 8-bit integer
      - object — Unsigned 16-bit integer
        - `U16` integer, required — Unsigned 16-bit integer
      - object — Unsigned 32-bit integer
        - `U32` integer, required — Unsigned 32-bit integer
      - object — Unsigned 64-bit integer
        - `U64` integer, required — Unsigned 64-bit integer
      - object — Signed 8-bit integer
        - `I8` integer, required — Signed 8-bit integer
      - object — Signed 16-bit integer
        - `I16` integer, required — Signed 16-bit integer
      - object — Signed 32-bit integer
        - `I32` integer, required — Signed 32-bit integer
      - object — Signed 64-bit integer
        - `I64` integer, required — Signed 64-bit integer
      - object — Unix timestamp: the number of seconds since 1 January 1970
        - `Timestamp` integer, required — Unix timestamp: the number of seconds since 1 January 1970
      - object — 32-bit floating point number
        - `F32` number, float, required — 32-bit floating point number
      - object — 64-bit floating point number
        - `F64` number, double, required — 64-bit floating point number
      - object — String value
        - `String` string, required — String value
      - object — String set value
        - `StringSet` string[], required — String set value
      - object — Point value: latitude/lat, longitude/lon
        - `Point` number[], required
      - 'None' — No value
  - `query_type_default` 'Union' | 'Intersection' | 'Phrase' | 'Not' — Specifies the default QueryType: The following query types are supported: - **Union** (OR, disjunction), - **Intersection** (AND, conjunction), - **Phrase** (""), - **Not** (-). The default QueryType is superseded if the query parser detects that a different query type is specified within the query string (+ - "").
  - `query_rewriting` union — Specifies whether query rewriting is enabled or disabled
    - 'SearchOnly' — Query rewriting disabled, returns query results for query as-is, returns no suggestions for corrected or completed query. No performance overhead for spelling correction and suggestions.
    - object — Query rewriting disabled, returns query results for original query string, returns suggestions for corrected or completed query. Additional latency for spelling suggestions.
      - `SearchSuggest` object, required — Query rewriting disabled, returns query results for original query string, returns suggestions for corrected or completed query. Additional latency for spelling suggestions.
        - `correct` integer, nullable — Enable query correction, for queries with query string length >= threshold A minimum length of 2 is advised to prevent irrelevant suggestions and results.
        - `distance` integer, required — The edit distance thresholds for suggestions: 1..2 recommended; higher values increase latency and memory consumption.
        - `term_length_threshold` integer[], nullable — Term length thresholds for each edit distance. None: max_dictionary_edit_distance for all terms lengths Some(\[4\]): max_dictionary_edit_distance for all terms lengths >= 4, Some(\[2,8\]): max_dictionary_edit_distance for all terms lengths >=2, max_dictionary_edit_distance +1 for all terms for lengths>=8
        - `complete` integer, nullable — Enable query completions, for queries with query string length >= threshold, in addition to spelling corrections A minimum length of 2 is advised to prevent irrelevant suggestions and results.
        - `length` integer, nullable — An option to limit maximum number of returned suggestions.
    - object — Query rewriting enabled, returns query results for spelling corrected or completed query string (=instant search), returns suggestions for corrected or completed query. Additional latency for spelling correction and suggestions.
      - `SearchRewrite` object, required — Query rewriting enabled, returns query results for spelling corrected or completed query string (=instant search), returns suggestions for corrected or completed query. Additional latency for spelling correction and suggestions.
        - `correct` integer, nullable — Enable query correction, for queries with query string length >= threshold A minimum length of 2 is advised to prevent irrelevant suggestions and results.
        - `distance` integer, required — The edit distance thresholds for suggestions: 1..2 recommended; higher values increase latency and memory consumption.
        - `term_length_threshold` integer[], nullable — Term length thresholds for each edit distance. None: max_dictionary_edit_distance for all terms lengths Some(\[4\]): max_dictionary_edit_distance for all terms lengths >= 4, Some(\[2,8\]): max_dictionary_edit_distance for all terms lengths >=2, max_dictionary_edit_distance +1 for all terms for lengths>=8
        - `complete` integer, nullable — Enable query completions, for queries with query string length >= threshold, in addition to spelling corrections A minimum length of 2 is advised to prevent irrelevant suggestions and results.
        - `length` integer, nullable — An option to limit maximum number of returned suggestions.
    - object — Search disabled, returns no query results, only returns suggestions for corrected or completed query.
      - `SuggestOnly` object, required — Search disabled, returns no query results, only returns suggestions for corrected or completed query.
        - `correct` integer, nullable — Enable query correction, for queries with query string length >= threshold A minimum length of 2 is advised to prevent irrelevant suggestions and results.
        - `distance` integer, required — The edit distance thresholds for suggestions: 1..2 recommended; higher values increase latency and memory consumption.
        - `term_length_threshold` integer[], nullable — Term length thresholds for each edit distance. None: max_dictionary_edit_distance for all terms lengths Some(\[4\]): max_dictionary_edit_distance for all terms lengths >= 4, Some(\[2,8\]): max_dictionary_edit_distance for all terms lengths >=2, max_dictionary_edit_distance +1 for all terms for lengths>=8
        - `complete` integer, nullable — Enable query completions, for queries with query string length >= threshold, in addition to spelling corrections A minimum length of 2 is advised to prevent irrelevant suggestions and results.
        - `length` integer, nullable — An option to limit maximum number of returned suggestions.
  - `search_mode` union — Specifies the default QueryMode: The following query modes are supported:
    - 'Lexical' — Lexical search mode: Search results are retrieved based on exact matches of query terms with the indexed terms.
    - object — Vector search mode: Search results are retrieved based on the similarity of query vectors with the indexed vectors.
      - `Vector` object, required — Vector search mode: Search results are retrieved based on the similarity of query vectors with the indexed vectors.
        - `similarity_threshold` number, float, nullable — Include only vectors with similarity scores above the specified threshold For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
        - `ann_mode` union, required — Specifies in which cluster to search for ANN results.
          - 'All' — Search in all clusters (default)
          - object — Search only in the clusters with the highest similarity scores to the query vector. The number of clusters to search is specified by the n-probe parameter. You cannot directly set a specific, guaranteed recall number (e.g., "always give me 95% recall@10"). There is no one-fits-all, there is no automatism. Instead, you manually tune parameters that control the tradeoff between query latency and accuracy. Because recall depends heavily on the structure of your specific data (distribution, dimensionality, and clustering) and queries, there is always a trial-and-error (benchmarking) phase required to determine the right settings for your data. Examples: wikipedia, VectorSimilarity::Dot, dimensions: 64, Precision::F32, Clustering::Auto, Clustering::I8, recall@10=95% -> Nprobe(55) wikipedia, VectorSimilarity::Dot, dimensions: 64, Precision::F32, Clustering::Auto, Clustering::I8, recall@10=99% -> Nprobe(140) sift1m, VectorSimilarity::Euclidean, dimensions: 128, Precision::F32, Clustering::Auto, Quantization::None, recall@10=95% -> Nprobe(11) sift1m, VectorSimilarity::Euclidean, dimensions: 128, Precision::F32, Clustering::Auto, Quantization::None, recall@10=99% -> Nprobe(22)
            - `Nprobe` integer, required — Search only in the clusters with the highest similarity scores to the query vector. The number of clusters to search is specified by the n-probe parameter. You cannot directly set a specific, guaranteed recall number (e.g., "always give me 95% recall@10"). There is no one-fits-all, there is no automatism. Instead, you manually tune parameters that control the tradeoff between query latency and accuracy. Because recall depends heavily on the structure of your specific data (distribution, dimensionality, and clustering) and queries, there is always a trial-and-error (benchmarking) phase required to determine the right settings for your data. Examples: wikipedia, VectorSimilarity::Dot, dimensions: 64, Precision::F32, Clustering::Auto, Clustering::I8, recall@10=95% -> Nprobe(55) wikipedia, VectorSimilarity::Dot, dimensions: 64, Precision::F32, Clustering::Auto, Clustering::I8, recall@10=99% -> Nprobe(140) sift1m, VectorSimilarity::Euclidean, dimensions: 128, Precision::F32, Clustering::Auto, Quantization::None, recall@10=95% -> Nprobe(11) sift1m, VectorSimilarity::Euclidean, dimensions: 128, Precision::F32, Clustering::Auto, Quantization::None, recall@10=99% -> Nprobe(22)
          - object — Search only in clusters with similarity scores to the query vector above the specified threshold. For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
            - `Similaritythreshold` number, float, required — Search only in clusters with similarity scores to the query vector above the specified threshold. For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
          - object — Search only in the clusters with the highest similarity scores to the query vector, but only if their similarity scores are above the specified threshold, and up to the number of clusters specified by the n-probe parameter. For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
            - `NprobeSimilaritythreshold` object[], required — Search only in the clusters with the highest similarity scores to the query vector, but only if their similarity scores are above the specified threshold, and up to the number of clusters specified by the n-probe parameter. For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
              - …
    - object — Hybrid search mode: Search results are retrieved based on a combination of lexical and vector search. The relevance score of search results is calculated based on RRF (Reciprocal Rank Fusion) of the result positions in lexical and vector search.
      - `Hybrid` object, required — Hybrid search mode: Search results are retrieved based on a combination of lexical and vector search. The relevance score of search results is calculated based on RRF (Reciprocal Rank Fusion) of the result positions in lexical and vector search.
        - `similarity_threshold` number, float, nullable — optional threshold to filter out low similarity scores For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
        - `ann_mode` union, required — Specifies in which cluster to search for ANN results.
          - 'All' — Search in all clusters (default)
          - object — Search only in the clusters with the highest similarity scores to the query vector. The number of clusters to search is specified by the n-probe parameter. You cannot directly set a specific, guaranteed recall number (e.g., "always give me 95% recall@10"). There is no one-fits-all, there is no automatism. Instead, you manually tune parameters that control the tradeoff between query latency and accuracy. Because recall depends heavily on the structure of your specific data (distribution, dimensionality, and clustering) and queries, there is always a trial-and-error (benchmarking) phase required to determine the right settings for your data. Examples: wikipedia, VectorSimilarity::Dot, dimensions: 64, Precision::F32, Clustering::Auto, Clustering::I8, recall@10=95% -> Nprobe(55) wikipedia, VectorSimilarity::Dot, dimensions: 64, Precision::F32, Clustering::Auto, Clustering::I8, recall@10=99% -> Nprobe(140) sift1m, VectorSimilarity::Euclidean, dimensions: 128, Precision::F32, Clustering::Auto, Quantization::None, recall@10=95% -> Nprobe(11) sift1m, VectorSimilarity::Euclidean, dimensions: 128, Precision::F32, Clustering::Auto, Quantization::None, recall@10=99% -> Nprobe(22)
            - `Nprobe` integer, required — Search only in the clusters with the highest similarity scores to the query vector. The number of clusters to search is specified by the n-probe parameter. You cannot directly set a specific, guaranteed recall number (e.g., "always give me 95% recall@10"). There is no one-fits-all, there is no automatism. Instead, you manually tune parameters that control the tradeoff between query latency and accuracy. Because recall depends heavily on the structure of your specific data (distribution, dimensionality, and clustering) and queries, there is always a trial-and-error (benchmarking) phase required to determine the right settings for your data. Examples: wikipedia, VectorSimilarity::Dot, dimensions: 64, Precision::F32, Clustering::Auto, Clustering::I8, recall@10=95% -> Nprobe(55) wikipedia, VectorSimilarity::Dot, dimensions: 64, Precision::F32, Clustering::Auto, Clustering::I8, recall@10=99% -> Nprobe(140) sift1m, VectorSimilarity::Euclidean, dimensions: 128, Precision::F32, Clustering::Auto, Quantization::None, recall@10=95% -> Nprobe(11) sift1m, VectorSimilarity::Euclidean, dimensions: 128, Precision::F32, Clustering::Auto, Quantization::None, recall@10=99% -> Nprobe(22)
          - object — Search only in clusters with similarity scores to the query vector above the specified threshold. For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
            - `Similaritythreshold` number, float, required — Search only in clusters with similarity scores to the query vector above the specified threshold. For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
          - object — Search only in the clusters with the highest similarity scores to the query vector, but only if their similarity scores are above the specified threshold, and up to the number of clusters specified by the n-probe parameter. For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
            - `NprobeSimilaritythreshold` object[], required — Search only in the clusters with the highest similarity scores to the query vector, but only if their similarity scores are above the specified threshold, and up to the number of clusters specified by the n-probe parameter. For dot product similarity, the similarity threshold should be between 0.0 and 1.0, where higher values indicate higher similarity (identical=1.0). For Euclidean distance similarity, the similarity threshold should be between 0.0 and infinity, where lower values indicate higher similarity (identical=0.0).
              - …

## Response `200`

Document deleted, returns indexed documents count

## Other responses

- `400` — Request object incorrect
- `401` — api_key missing
- `404` — api_key does not exists

## Changes

- **2026-06-22** `39cce1ef7d95` — 1 info
  - api operation id `delete_document_by_object_api` removed and replaced with `delete_document_by_request_object`
- **2026-06-21** `4cfd9d95648c` — 1 info
  - api operation id `delete_document_by_request_object` removed and replaced with `delete_document_by_object_api`

[Change history](https://skmtc.dev/seekstorm/apis/seekstorm-rest-api-documentation/changes/api/v1/index/:index_id/doc/delete.md)

---

[API](https://skmtc.dev/seekstorm/apis/seekstorm-rest-api-documentation.md) · [All operations](https://skmtc.dev/seekstorm/apis/seekstorm-rest-api-documentation/llms.txt) · [OpenAPI document](https://skmtc-service-production.skmtc.workers.dev/v1/apis/seekstorm/seekstorm-rest-api-documentation/revisions/f464579dd19f/schema)