Get segment information

GET /_cat/segments

Get low-level information about the Lucene segments in index shards. For data streams, the API returns information about the backing indices. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the index segments API.

Query parameters

  • bytes string

    The unit used to display byte values.

    Values are b, kb, mb, gb, tb, or pb.

  • local boolean

    If true, the request computes the list of selected nodes from the local cluster state. If false the list of selected nodes are computed from the cluster state of the master node. In both cases the coordinating node will send requests for further information to each selected node.

  • Period to wait for a connection to the master node.

Responses

  • Hide response attributes Show response attributes object
    • index string
    • shard string

      The shard name.

    • prirep string

      The shard type: primary or replica.

    • ip string

      The IP address of the node where it lives.

    • id string
    • segment string

      The segment name, which is derived from the segment generation and used internally to create file names in the directory of the shard.

    • The segment generation number. Elasticsearch increments this generation number for each segment written then uses this number to derive the segment name.

    • The number of documents in the segment. This excludes deleted documents and counts any nested documents separately from their parents. It also excludes documents which were indexed recently and do not yet belong to a segment.

    • The number of deleted documents in the segment, which might be higher or lower than the number of delete operations you have performed. This number excludes deletes that were performed recently and do not yet belong to a segment. Deleted documents are cleaned up by the automatic merge process if it makes sense to do so. Also, Elasticsearch creates extra deleted documents to internally track the recent history of operations on a shard.

    • If true, the segment is synced to disk. Segments that are synced can survive a hard reboot. If false, the data from uncommitted segments is also stored in the transaction log so that Elasticsearch is able to replay changes on the next start.

    • If true, the segment is searchable. If false, the segment has most likely been written to disk but needs a refresh to be searchable.

    • version string
    • compound string

      If true, the segment is stored in a compound file. This means Lucene merged all files from the segment in a single file to save file descriptors.

GET /_cat/segments
curl \
 --request GET http://api.example.com/_cat/segments
Response examples (200)
[
  {
    "index": "string",
    "shard": "string",
    "prirep": "string",
    "ip": "string",
    "id": "string",
    "segment": "string",
    "generation": "string",
    "docs.count": "string",
    "docs.deleted": "string",
    "": 42.0,
    "committed": "string",
    "searchable": "string",
    "version": "string",
    "compound": "string"
  }
]



































































































































































































































































































































Update the connector scheduling Beta

PUT /_connector/{connector_id}/_scheduling

Path parameters

  • connector_id string Required

    The unique identifier of the connector to be updated

application/json

Body Required

  • scheduling object Required

    Additional properties are allowed.

    Hide scheduling attributes Show scheduling attributes object
    • Additional properties are allowed.

      Hide access_control attributes Show access_control attributes object
      • enabled boolean Required
      • interval string Required

        The interval is expressed using the crontab syntax

    • full object

      Additional properties are allowed.

      Hide full attributes Show full attributes object
      • enabled boolean Required
      • interval string Required

        The interval is expressed using the crontab syntax

    • Additional properties are allowed.

      Hide incremental attributes Show incremental attributes object
      • enabled boolean Required
      • interval string Required

        The interval is expressed using the crontab syntax

Responses

  • 200 application/json
    Hide response attribute Show response attribute object
    • result string Required

      Values are created, updated, deleted, not_found, or noop.

PUT /_connector/{connector_id}/_scheduling
curl \
 --request PUT http://api.example.com/_connector/{connector_id}/_scheduling \
 --header "Content-Type: application/json" \
 --data '"{\n    \"scheduling\": {\n        \"access_control\": {\n            \"enabled\": true,\n            \"interval\": \"0 10 0 * * ?\"\n        },\n        \"full\": {\n            \"enabled\": true,\n            \"interval\": \"0 20 0 * * ?\"\n        },\n        \"incremental\": {\n            \"enabled\": false,\n            \"interval\": \"0 30 0 * * ?\"\n        }\n    }\n}"'
{
    "scheduling": {
        "access_control": {
            "enabled": true,
            "interval": "0 10 0 * * ?"
        },
        "full": {
            "enabled": true,
            "interval": "0 20 0 * * ?"
        },
        "incremental": {
            "enabled": false,
            "interval": "0 30 0 * * ?"
        }
    }
}
{
    "scheduling": {
        "full": {
            "enabled": true,
            "interval": "0 10 0 * * ?"
        }
    }
}
Response examples (200)
{
  "result": "updated"
}







































































































































































Delete documents Added in 5.0.0

POST /{index}/_delete_by_query

Deletes documents that match the specified query.

If the Elasticsearch security features are enabled, you must have the following index privileges for the target data stream, index, or alias:

  • read
  • delete or write

You can specify the query criteria in the request URI or the request body using the same syntax as the search API. When you submit a delete by query request, Elasticsearch gets a snapshot of the data stream or index when it begins processing the request and deletes matching documents using internal versioning. If a document changes between the time that the snapshot is taken and the delete operation is processed, it results in a version conflict and the delete operation fails.

NOTE: Documents with a version equal to 0 cannot be deleted using delete by query because internal versioning does not support 0 as a valid version number.

While processing a delete by query request, Elasticsearch performs multiple search requests sequentially to find all of the matching documents to delete. A bulk delete request is performed for each batch of matching documents. If a search or bulk request is rejected, the requests are retried up to 10 times, with exponential back off. If the maximum retry limit is reached, processing halts and all failed requests are returned in the response. Any delete requests that completed successfully still stick, they are not rolled back.

You can opt to count version conflicts instead of halting and returning by setting conflicts to proceed. Note that if you opt to count version conflicts the operation could attempt to delete more documents from the source than max_docs until it has successfully deleted max_docs documents, or it has gone through every document in the source query.

Throttling delete requests

To control the rate at which delete by query issues batches of delete operations, you can set requests_per_second to any positive decimal number. This pads each batch with a wait time to throttle the rate. Set requests_per_second to -1 to disable throttling.

Throttling uses a wait time between batches so that the internal scroll requests can be given a timeout that takes the request padding into account. The padding time is the difference between the batch size divided by the requests_per_second and the time spent writing. By default the batch size is 1000, so if requests_per_second is set to 500:

target_time = 1000 / 500 per second = 2 seconds
wait_time = target_time - write_time = 2 seconds - .5 seconds = 1.5 seconds

Since the batch is issued as a single _bulk request, large batch sizes cause Elasticsearch to create many requests and wait before starting the next set. This is "bursty" instead of "smooth".

Slicing

Delete by query supports sliced scroll to parallelize the delete process. This can improve efficiency and provide a convenient way to break the request down into smaller parts.

Setting slices to auto lets Elasticsearch choose the number of slices to use. This setting will use one slice per shard, up to a certain limit. If there are multiple source data streams or indices, it will choose the number of slices based on the index or backing index with the smallest number of shards. Adding slices to the delete by query operation creates sub-requests which means it has some quirks:

  • You can see these requests in the tasks APIs. These sub-requests are "child" tasks of the task for the request with slices.
  • Fetching the status of the task for the request with slices only contains the status of completed slices.
  • These sub-requests are individually addressable for things like cancellation and rethrottling.
  • Rethrottling the request with slices will rethrottle the unfinished sub-request proportionally.
  • Canceling the request with slices will cancel each sub-request.
  • Due to the nature of slices each sub-request won't get a perfectly even portion of the documents. All documents will be addressed, but some slices may be larger than others. Expect larger slices to have a more even distribution.
  • Parameters like requests_per_second and max_docs on a request with slices are distributed proportionally to each sub-request. Combine that with the earlier point about distribution being uneven and you should conclude that using max_docs with slices might not result in exactly max_docs documents being deleted.
  • Each sub-request gets a slightly different snapshot of the source data stream or index though these are all taken at approximately the same time.

If you're slicing manually or otherwise tuning automatic slicing, keep in mind that:

  • Query performance is most efficient when the number of slices is equal to the number of shards in the index or backing index. If that number is large (for example, 500), choose a lower number as too many slices hurts performance. Setting slices higher than the number of shards generally does not improve efficiency and adds overhead.
  • Delete performance scales linearly across available resources with the number of slices.

Whether query or delete performance dominates the runtime depends on the documents being reindexed and cluster resources.

Cancel a delete by query operation

Any delete by query can be canceled using the task cancel API. For example:

POST _tasks/r1A2WoRbTwKZ516z6NEs5A:36619/_cancel

The task ID can be found by using the get tasks API.

Cancellation should happen quickly but might take a few seconds. The get task status API will continue to list the delete by query task until this task checks that it has been cancelled and terminates itself.

Path parameters

  • index string | array[string] Required

    A comma-separated list of data streams, indices, and aliases to search. It supports wildcards (*). To search all data streams or indices, omit this parameter or use * or _all.

Query parameters

  • If false, the request returns an error if any wildcard expression, index alias, or _all value targets only missing or closed indices. This behavior applies even if the request targets other open indices. For example, a request targeting foo*,bar* returns an error if an index starts with foo but no index starts with bar.

  • analyzer string

    Analyzer to use for the query string. This parameter can be used only when the q query string parameter is specified.

  • If true, wildcard and prefix queries are analyzed. This parameter can be used only when the q query string parameter is specified.

  • What to do if delete by query hits version conflicts: abort or proceed.

    Values are abort or proceed.

  • The default operator for query string query: AND or OR. This parameter can be used only when the q query string parameter is specified.

    Values are and, AND, or, or OR.

  • df string

    The field to use as default where no field prefix is given in the query string. This parameter can be used only when the q query string parameter is specified.

  • expand_wildcards string | array[string]

    The type of index that wildcard patterns can match. If the request can target data streams, this argument determines whether wildcard expressions match hidden data streams. It supports comma-separated values, such as open,hidden.

  • from number

    Starting offset (default: 0)

  • If false, the request returns an error if it targets a missing or closed index.

  • lenient boolean

    If true, format-based query failures (such as providing text to a numeric field) in the query string will be ignored. This parameter can be used only when the q query string parameter is specified.

  • max_docs number

    The maximum number of documents to process. Defaults to all documents. When set to a value less then or equal to scroll_size, a scroll will not be used to retrieve the results for the operation.

  • The node or shard the operation should be performed on. It is random by default.

  • refresh boolean

    If true, Elasticsearch refreshes all shards involved in the delete by query after the request completes. This is different than the delete API's refresh parameter, which causes just the shard that received the delete request to be refreshed. Unlike the delete API, it does not support wait_for.

  • If true, the request cache is used for this request. Defaults to the index-level setting.

  • The throttle for this request in sub-requests per second.

  • routing string

    A custom value used to route operations to a specific shard.

  • q string

    A query in the Lucene query string syntax.

  • scroll string

    The period to retain the search context for scrolling.

  • The size of the scroll request that powers the operation.

  • The explicit timeout for each search request. It defaults to no timeout.

  • The type of the search operation. Available options include query_then_fetch and dfs_query_then_fetch.

    Values are query_then_fetch or dfs_query_then_fetch.

  • slices number | string

    The number of slices this task should be divided into.

  • sort array[string]

    A comma-separated list of <field>:<direction> pairs.

  • stats array[string]

    The specific tag of the request for logging and statistical purposes.

  • The maximum number of documents to collect for each shard. If a query reaches this limit, Elasticsearch terminates the query early. Elasticsearch collects documents before sorting.

    Use with caution. Elasticsearch applies this parameter to each shard handling the request. When possible, let Elasticsearch perform early termination automatically. Avoid specifying this parameter for requests that target data streams with backing indices across multiple data tiers.

  • timeout string

    The period each deletion request waits for active shards.

  • version boolean

    If true, returns the document version as part of a hit.

  • wait_for_active_shards number | string

    The number of shard copies that must be active before proceeding with the operation. Set to all or any positive integer up to the total number of shards in the index (number_of_replicas+1). The timeout value controls how long each write request waits for unavailable shards to become available.

  • If true, the request blocks until the operation is complete. If false, Elasticsearch performs some preflight checks, launches the request, and returns a task you can use to cancel or get the status of the task. Elasticsearch creates a record of this task as a document at .tasks/task/${taskId}. When you are done with a task, you should delete the task document so Elasticsearch can reclaim the space.

application/json

Body Required

  • max_docs number

    The maximum number of documents to delete.

  • query object

    An Elasticsearch Query DSL (Domain Specific Language) object that defines a query.

    Additional properties are allowed.

  • slice object

    Additional properties are allowed.

    Hide slice attributes Show slice attributes object
    • field string

      Path to field or array of paths. Some API's support wildcards in the path to select multiple fields.

    • id string Required
    • max number Required

Responses

  • 200 application/json
    Hide response attributes Show response attributes object
    • batches number

      The number of scroll responses pulled back by the delete by query.

    • deleted number

      The number of documents that were successfully deleted.

    • failures array[object]

      An array of failures if there were any unrecoverable errors during the process. If this array is not empty, the request ended abnormally because of those failures. Delete by query is implemented using batches and any failures cause the entire process to end but all failures in the current batch are collected into the array. You can use the conflicts option to prevent reindex from ending on version conflicts.

      Hide failures attributes Show failures attributes object
      • cause object Required

        Additional properties are allowed.

        Hide cause attributes Show cause attributes object
        • type string Required

          The type of error

        • reason string

          A human-readable explanation of the error, in English.

        • The server stack trace. Present only if the error_trace=true parameter was sent with the request.

        • Additional properties are allowed.

        • root_cause array[object]

          Additional properties are allowed.

        • suppressed array[object]

          Additional properties are allowed.

      • id string Required
      • index string Required
      • status number Required
      • type string Required
    • noops number

      This field is always equal to zero for delete by query. It exists only so that delete by query, update by query, and reindex APIs return responses with the same structure.

    • The number of requests per second effectively run during the delete by query.

    • retries object

      Additional properties are allowed.

      Hide retries attributes Show retries attributes object
      • bulk number Required

        The number of bulk actions retried.

    • slice_id number
    • A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

    • Time unit for milliseconds

    • A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

    • Time unit for milliseconds

    • timed_out boolean

      If true, some requests run during the delete by query operation timed out.

    • took number

      Time unit for milliseconds

    • total number

      The number of documents that were successfully processed.

    • The number of version conflicts that the delete by query hit.

POST /{index}/_delete_by_query
curl \
 --request POST http://api.example.com/{index}/_delete_by_query \
 --header "Content-Type: application/json" \
 --data '"{\n  \"query\": {\n    \"match_all\": {}\n  }\n}"'
Run `POST /my-index-000001,my-index-000002/_delete_by_query` to delete all documents from multiple data streams or indices.
{
  "query": {
    "match_all": {}
  }
}
Run `POST my-index-000001/_delete_by_query` to delete a document by using a unique attribute.
{
  "query": {
    "term": {
      "user.id": "kimchy"
    }
  },
  "max_docs": 1
}
Run `POST my-index-000001/_delete_by_query` to slice a delete by query manually. Provide a slice ID and total number of slices.
{
  "slice": {
    "id": 0,
    "max": 2
  },
  "query": {
    "range": {
      "http.response.bytes": {
        "lt": 2000000
      }
    }
  }
}
Run `POST my-index-000001/_delete_by_query?refresh&slices=5` to let delete by query automatically parallelize using sliced scroll to slice on `_id`. The `slices` query parameter value specifies the number of slices to use.
{
  "query": {
    "range": {
      "http.response.bytes": {
        "lt": 2000000
      }
    }
  }
}
Response examples (200)
A successful response from `POST /my-index-000001/_delete_by_query`.
{
  "took" : 147,
  "timed_out": false,
  "total": 119,
  "deleted": 119,
  "batches": 1,
  "version_conflicts": 0,
  "noops": 0,
  "retries": {
    "bulk": 0,
    "search": 0
  },
  "throttled_millis": 0,
  "requests_per_second": -1.0,
  "throttled_until_millis": 0,
  "failures" : [ ]
}
































Get multiple term vectors

GET /_mtermvectors

Get multiple term vectors with a single request. You can specify existing documents by index and ID or provide artificial documents in the body of the request. You can specify the index in the request body or request URI. The response contains a docs array with all the fetched termvectors. Each element has the structure provided by the termvectors API.

Artificial documents

You can also use mtermvectors to generate term vectors for artificial documents provided in the body of the request. The mapping used is determined by the specified _index.

Query parameters

  • ids array[string]

    A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body

  • fields string | array[string]

    A comma-separated list or wildcard expressions of fields to include in the statistics. It is used as the default list unless a specific field list is provided in the completion_fields or fielddata_fields parameters.

  • If true, the response includes the document count, sum of document frequencies, and sum of total term frequencies.

  • offsets boolean

    If true, the response includes term offsets.

  • payloads boolean

    If true, the response includes term payloads.

  • positions boolean

    If true, the response includes term positions.

  • The node or shard the operation should be performed on. It is random by default.

  • realtime boolean

    If true, the request is real-time as opposed to near-real-time.

  • routing string

    A custom value used to route operations to a specific shard.

  • If true, the response includes term frequency and document frequency.

  • version number

    If true, returns the document version as part of a hit.

  • The version type.

    Values are internal, external, external_gte, or force.

application/json

Body

  • docs array[object]

    An array of existing or artificial documents.

    Hide docs attributes Show docs attributes object
    • _id string
    • _index string
    • doc object

      An artificial document (a document not present in the index) for which you want to retrieve term vectors.

      Additional properties are allowed.

    • fields string | array[string]
    • If true, the response includes the document count, sum of document frequencies, and sum of total term frequencies.

    • filter object

      Additional properties are allowed.

      Hide filter attributes Show filter attributes object
      • Ignore words which occur in more than this many docs. Defaults to unbounded.

      • The maximum number of terms that must be returned per field.

      • Ignore words with more than this frequency in the source doc. It defaults to unbounded.

      • The maximum word length above which words will be ignored. Defaults to unbounded.

      • Ignore terms which do not occur in at least this many docs.

      • Ignore words with less than this frequency in the source doc.

      • The minimum word length below which words will be ignored.

    • offsets boolean

      If true, the response includes term offsets.

    • payloads boolean

      If true, the response includes term payloads.

    • positions boolean

      If true, the response includes term positions.

    • routing string
    • If true, the response includes term frequency and document frequency.

    • version number
    • Values are internal, external, external_gte, or force.

  • ids array[string]

    A simplified syntax to specify documents by their ID if they're in the same index.

Responses

  • 200 application/json
    Hide response attribute Show response attribute object
    • docs array[object] Required
      Hide docs attributes Show docs attributes object
      • _id string
      • _index string Required
      • _version number
      • took number
      • found boolean
      • Hide term_vectors attribute Show term_vectors attribute object
        • * object Additional properties

          Additional properties are allowed.

          Hide * attributes Show * attributes object
          • Additional properties are allowed.

            Hide field_statistics attributes Show field_statistics attributes object
          • terms object Required
            Hide terms attribute Show terms attribute object
            • * object Additional properties

              Additional properties are allowed.

      • error object

        Additional properties are allowed.

        Hide error attributes Show error attributes object
        • type string Required

          The type of error

        • reason string

          A human-readable explanation of the error, in English.

        • The server stack trace. Present only if the error_trace=true parameter was sent with the request.

        • Additional properties are allowed.

        • root_cause array[object]

          Additional properties are allowed.

        • suppressed array[object]

          Additional properties are allowed.

GET /_mtermvectors
curl \
 --request GET http://api.example.com/_mtermvectors \
 --header "Content-Type: application/json" \
 --data '"{\n  \"docs\": [\n      {\n        \"_id\": \"2\",\n        \"fields\": [\n            \"message\"\n        ],\n        \"term_statistics\": true\n      },\n      {\n        \"_id\": \"1\"\n      }\n  ]\n}"'
Run `POST /my-index-000001/_mtermvectors`. When you specify an index in the request URI, the index does not need to be specified for each documents in the request body.
{
  "docs": [
      {
        "_id": "2",
        "fields": [
            "message"
        ],
        "term_statistics": true
      },
      {
        "_id": "1"
      }
  ]
}
Run `POST /my-index-000001/_mtermvectors`. If all requested documents are in same index and the parameters are the same, you can use a simplified syntax.
{
  "ids": [ "1", "2" ],
  "parameters": {
    "fields": [
      "message"
    ],
    "term_statistics": true
  }
}
Run `POST /_mtermvectors` to generate term vectors for artificial documents provided in the body of the request. The mapping used is determined by the specified `_index`.
{
  "docs": [
      {
        "_index": "my-index-000001",
        "doc" : {
            "message" : "test test test"
        }
      },
      {
        "_index": "my-index-000001",
        "doc" : {
          "message" : "Another test ..."
        }
      }
  ]
}
Response examples (200)
{
  "docs": [
    {
      "_id": "string",
      "_index": "string",
      "_version": 42.0,
      "took": 42.0,
      "found": true,
      "term_vectors": {
        "additionalProperty1": {
          "field_statistics": {
            "doc_count": 42.0,
            "sum_doc_freq": 42.0,
            "sum_ttf": 42.0
          },
          "terms": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "additionalProperty2": {
          "field_statistics": {
            "doc_count": 42.0,
            "sum_doc_freq": 42.0,
            "sum_ttf": 42.0
          },
          "terms": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        }
      },
      "error": {
        "type": "string",
        "reason": "string",
        "stack_trace": "string",
        "caused_by": {},
        "root_cause": [
          {}
        ],
        "suppressed": [
          {}
        ]
      }
    }
  ]
}
































Get term vector information

POST /{index}/_termvectors

Get information and statistics about terms in the fields of a particular document.

You can retrieve term vectors for documents stored in the index or for artificial documents passed in the body of the request. You can specify the fields you are interested in through the fields parameter or by adding the fields to the request body. For example:

GET /my-index-000001/_termvectors/1?fields=message

Fields can be specified using wildcards, similar to the multi match query.

Term vectors are real-time by default, not near real-time. This can be changed by setting realtime parameter to false.

You can request three types of values: term information, term statistics, and field statistics. By default, all term information and field statistics are returned for all fields but term statistics are excluded.

Term information

  • term frequency in the field (always returned)
  • term positions (positions: true)
  • start and end offsets (offsets: true)
  • term payloads (payloads: true), as base64 encoded bytes

If the requested information wasn't stored in the index, it will be computed on the fly if possible. Additionally, term vectors could be computed for documents not even existing in the index, but instead provided by the user.


Start and end offsets assume UTF-16 encoding is being used. If you want to use these offsets in order to get the original text that produced this token, you should make sure that the string you are taking a sub-string of is also encoded using UTF-16.

Behaviour

The term and field statistics are not accurate. Deleted documents are not taken into account. The information is only retrieved for the shard the requested document resides in. The term and field statistics are therefore only useful as relative measures whereas the absolute numbers have no meaning in this context. By default, when requesting term vectors of artificial documents, a shard to get the statistics from is randomly selected. Use routing only to hit a particular shard.

Path parameters

  • index string Required

    The name of the index that contains the document.

Query parameters

  • fields string | array[string]

    A comma-separated list or wildcard expressions of fields to include in the statistics. It is used as the default list unless a specific field list is provided in the completion_fields or fielddata_fields parameters.

  • If true, the response includes:

    • The document count (how many documents contain this field).
    • The sum of document frequencies (the sum of document frequencies for all terms in this field).
    • The sum of total term frequencies (the sum of total term frequencies of each term in this field).
  • offsets boolean

    If true, the response includes term offsets.

  • payloads boolean

    If true, the response includes term payloads.

  • positions boolean

    If true, the response includes term positions.

  • The node or shard the operation should be performed on. It is random by default.

  • realtime boolean

    If true, the request is real-time as opposed to near-real-time.

  • routing string

    A custom value that is used to route operations to a specific shard.

  • If true, the response includes:

    • The total term frequency (how often a term occurs in all documents).
    • The document frequency (the number of documents containing the current term).

    By default these values are not returned since term statistics can have a serious performance impact.

  • version number

    If true, returns the document version as part of a hit.

  • The version type.

    Values are internal, external, external_gte, or force.

application/json

Body

  • doc object

    An artificial document (a document not present in the index) for which you want to retrieve term vectors.

    Additional properties are allowed.

  • filter object

    Additional properties are allowed.

    Hide filter attributes Show filter attributes object
    • Ignore words which occur in more than this many docs. Defaults to unbounded.

    • The maximum number of terms that must be returned per field.

    • Ignore words with more than this frequency in the source doc. It defaults to unbounded.

    • The maximum word length above which words will be ignored. Defaults to unbounded.

    • Ignore terms which do not occur in at least this many docs.

    • Ignore words with less than this frequency in the source doc.

    • The minimum word length below which words will be ignored.

  • Override the default per-field analyzer. This is useful in order to generate term vectors in any fashion, especially when using artificial documents. When providing an analyzer for a field that already stores term vectors, the term vectors will be regenerated.

    Hide per_field_analyzer attribute Show per_field_analyzer attribute object
    • * string Additional properties

Responses

  • 200 application/json
    Hide response attributes Show response attributes object
    • found boolean Required
    • _id string
    • _index string Required
    • Hide term_vectors attribute Show term_vectors attribute object
      • * object Additional properties

        Additional properties are allowed.

        Hide * attributes Show * attributes object
    • took number Required
    • _version number Required
POST /{index}/_termvectors
curl \
 --request POST http://api.example.com/{index}/_termvectors \
 --header "Content-Type: application/json" \
 --data '"{\n  \"fields\" : [\"text\"],\n  \"offsets\" : true,\n  \"payloads\" : true,\n  \"positions\" : true,\n  \"term_statistics\" : true,\n  \"field_statistics\" : true\n}"'
Run `GET /my-index-000001/_termvectors/1` to return all information and statistics for field `text` in document 1.
{
  "fields" : ["text"],
  "offsets" : true,
  "payloads" : true,
  "positions" : true,
  "term_statistics" : true,
  "field_statistics" : true
}
Run `GET /my-index-000001/_termvectors/1` to set per-field analyzers. A different analyzer than the one at the field may be provided by using the `per_field_analyzer` parameter.
{
  "doc" : {
    "fullname" : "John Doe",
    "text" : "test test test"
  },
  "fields": ["fullname"],
  "per_field_analyzer" : {
    "fullname": "keyword"
  }
}
Run `GET /imdb/_termvectors` to filter the terms returned based on their tf-idf scores. It returns the three most "interesting" keywords from the artificial document having the given "plot" field value. Notice that the keyword "Tony" or any stop words are not part of the response, as their tf-idf must be too low.
{
  "doc": {
    "plot": "When wealthy industrialist Tony Stark is forced to build an armored suit after a life-threatening incident, he ultimately decides to use its technology to fight against evil."
  },
  "term_statistics": true,
  "field_statistics": true,
  "positions": false,
  "offsets": false,
  "filter": {
    "max_num_terms": 3,
    "min_term_freq": 1,
    "min_doc_freq": 1
  }
}
Run `GET /my-index-000001/_termvectors/1`. Term vectors which are not explicitly stored in the index are automatically computed on the fly. This request returns all information and statistics for the fields in document 1, even though the terms haven't been explicitly stored in the index. Note that for the field text, the terms are not regenerated.
{
  "fields" : ["text", "some_field_without_term_vectors"],
  "offsets" : true,
  "positions" : true,
  "term_statistics" : true,
  "field_statistics" : true
}
Run `GET /my-index-000001/_termvectors`. Term vectors can be generated for artificial documents, that is for documents not present in the index. If dynamic mapping is turned on (default), the document fields not in the original mapping will be dynamically created.
{
  "doc" : {
    "fullname" : "John Doe",
    "text" : "test test test"
  }
}
Response examples (200)
A successful response from `GET /my-index-000001/_termvectors/1`.
{
  "_index": "my-index-000001",
  "_id": "1",
  "_version": 1,
  "found": true,
  "took": 6,
  "term_vectors": {
    "text": {
      "field_statistics": {
        "sum_doc_freq": 4,
        "doc_count": 2,
        "sum_ttf": 6
      },
      "terms": {
        "test": {
          "doc_freq": 2,
          "ttf": 4,
          "term_freq": 3,
          "tokens": [
            {
              "position": 0,
              "start_offset": 0,
              "end_offset": 4,
              "payload": "d29yZA=="
            },
            {
              "position": 1,
              "start_offset": 5,
              "end_offset": 9,
              "payload": "d29yZA=="
            },
            {
              "position": 2,
              "start_offset": 10,
              "end_offset": 14,
              "payload": "d29yZA=="
            }
          ]
        }
      }
    }
  }
}
A successful response from `GET /my-index-000001/_termvectors` with `per_field_analyzer` in the request body.
{
  "_index": "my-index-000001",
  "_version": 0,
  "found": true,
  "took": 6,
  "term_vectors": {
    "fullname": {
      "field_statistics": {
          "sum_doc_freq": 2,
          "doc_count": 4,
          "sum_ttf": 4
      },
      "terms": {
          "John Doe": {
            "term_freq": 1,
            "tokens": [
                {
                  "position": 0,
                  "start_offset": 0,
                  "end_offset": 8
                }
            ]
          }
      }
    }
  }
}
A successful response from `GET /my-index-000001/_termvectors` with a `filter` in the request body.
{
  "_index": "imdb",
  "_version": 0,
  "found": true,
  "term_vectors": {
      "plot": {
        "field_statistics": {
            "sum_doc_freq": 3384269,
            "doc_count": 176214,
            "sum_ttf": 3753460
        },
        "terms": {
            "armored": {
              "doc_freq": 27,
              "ttf": 27,
              "term_freq": 1,
              "score": 9.74725
            },
            "industrialist": {
              "doc_freq": 88,
              "ttf": 88,
              "term_freq": 1,
              "score": 8.590818
            },
            "stark": {
              "doc_freq": 44,
              "ttf": 47,
              "term_freq": 1,
              "score": 9.272792
            }
        }
      }
  }
}

Update a document

POST /{index}/_update/{id}

Update a document by running a script or passing a partial document.

If the Elasticsearch security features are enabled, you must have the index or write index privilege for the target index or index alias.

The script can update, delete, or skip modifying the document. The API also supports passing a partial document, which is merged into the existing document. To fully replace an existing document, use the index API. This operation:

  • Gets the document (collocated with the shard) from the index.
  • Runs the specified script.
  • Indexes the result.

The document must still be reindexed, but using this API removes some network roundtrips and reduces chances of version conflicts between the GET and the index operation.

The _source field must be enabled to use this API. In addition to _source, you can access the following variables through the ctx map: _index, _type, _id, _version, _routing, and _now (the current timestamp).

Path parameters

  • index string Required

    The name of the target index. By default, the index is created automatically if it doesn't exist.

  • id string Required

    A unique identifier for the document to be updated.

Query parameters

  • Only perform the operation if the document has this primary term.

  • Only perform the operation if the document has this sequence number.

  • True or false if to include the document source in the error message in case of parsing errors.

  • lang string

    The script language.

  • refresh string

    If 'true', Elasticsearch refreshes the affected shards to make this operation visible to search. If 'wait_for', it waits for a refresh to make this operation visible to search. If 'false', it does nothing with refreshes.

    Values are true, false, or wait_for.

  • If true, the destination must be an index alias.

  • The number of times the operation should be retried when a conflict occurs.

  • routing string

    A custom value used to route operations to a specific shard.

  • timeout string

    The period to wait for the following operations: dynamic mapping updates and waiting for active shards. Elasticsearch waits for at least the timeout period before failing. The actual wait time could be longer, particularly when multiple waits occur.

  • wait_for_active_shards number | string

    The number of copies of each shard that must be active before proceeding with the operation. Set to 'all' or any positive integer up to the total number of shards in the index (number_of_replicas+1). The default value of 1 means it waits for each primary shard to be active.

  • _source boolean | string | array[string]

    If false, source retrieval is turned off. You can also specify a comma-separated list of the fields you want to retrieve.

  • _source_excludes string | array[string]

    The source fields you want to exclude.

  • _source_includes string | array[string]

    The source fields you want to retrieve.

application/json

Body Required

  • If true, the result in the response is set to noop (no operation) when there are no changes to the document.

  • doc object

    A partial update to an existing document. If both doc and script are specified, doc is ignored.

    Additional properties are allowed.

  • If true, use the contents of 'doc' as the value of 'upsert'. NOTE: Using ingest pipelines with doc_as_upsert is not supported.

  • script object

    Additional properties are allowed.

    Hide script attributes Show script attributes object
    • source string

      The script source.

    • id string
    • params object

      Specifies any named parameters that are passed into the script as variables. Use parameters instead of hard-coded values to decrease compile time.

      Hide params attribute Show params attribute object
      • * object Additional properties

        Additional properties are allowed.

    • lang string

      Any of:

      Values are painless, expression, mustache, or java.

    • options object
      Hide options attribute Show options attribute object
      • * string Additional properties
  • If true, run the script whether or not the document exists.

  • _source boolean | object

    Defines how to fetch a source. Fetching can be disabled entirely, or the source can be filtered.

    One of:
  • upsert object

    If the document does not already exist, the contents of 'upsert' are inserted as a new document. If the document exists, the 'script' is run.

    Additional properties are allowed.

Responses

  • 200 application/json
    Hide response attributes Show response attributes object
POST /{index}/_update/{id}
curl \
 --request POST http://api.example.com/{index}/_update/{id} \
 --header "Content-Type: application/json" \
 --data '"{\n  \"script\" : {\n    \"source\": \"ctx._source.counter += params.count\",\n    \"lang\": \"painless\",\n    \"params\" : {\n      \"count\" : 4\n    }\n  }\n}"'
Run `POST test/_update/1` to increment a counter by using a script.
{
  "script" : {
    "source": "ctx._source.counter += params.count",
    "lang": "painless",
    "params" : {
      "count" : 4
    }
  }
}
Run `POST test/_update/1` to use a script to add a tag to a list of tags. In this example, it is just a list, so the tag is added even it exists.
{
  "script": {
    "source": "ctx._source.tags.add(params.tag)",
    "lang": "painless",
    "params": {
      "tag": "blue"
    }
  }
}
Run `POST test/_update/1` to use a script to remove a tag from a list of tags. The Painless function to remove a tag takes the array index of the element you want to remove. To avoid a possible runtime error, you first need to make sure the tag exists. If the list contains duplicates of the tag, this script just removes one occurrence.
{
  "script": {
    "source": "if (ctx._source.tags.contains(params.tag)) { ctx._source.tags.remove(ctx._source.tags.indexOf(params.tag)) }",
    "lang": "painless",
    "params": {
      "tag": "blue"
    }
  }
}
Run `POST test/_update/1` to use a script to add a field `new_field` to the document.
{
  "script" : "ctx._source.new_field = 'value_of_new_field'"
}
Run `POST test/_update/1` to use a script to remove a field `new_field` from the document.
{
  "script" : "ctx._source.remove('new_field')"
}
Run `POST test/_update/1` to use a script to remove a subfield from an object field.
{
  "script": "ctx._source['my-object'].remove('my-subfield')"
}
Run `POST test/_update/1` to change the operation that runs from within the script. For example, this request deletes the document if the `tags` field contains `green`, otherwise it does nothing (`noop`).
{
  "script": {
    "source": "if (ctx._source.tags.contains(params.tag)) { ctx.op = 'delete' } else { ctx.op = 'noop' }",
    "lang": "painless",
    "params": {
      "tag": "green"
    }
  }
}
Run `POST test/_update/1` to do a partial update that adds a new field to the existing document.
{
  "doc": {
    "name": "new_name"
  }
}
Run `POST test/_update/1` to perfom an upsert. If the document does not already exist, the contents of the upsert element are inserted as a new document. If the document exists, the script is run.
{
  "script": {
    "source": "ctx._source.counter += params.count",
    "lang": "painless",
    "params": {
      "count": 4
    }
  },
  "upsert": {
    "counter": 1
  }
}
Run `POST test/_update/1` to perform a scripted upsert. When `scripted_upsert` is `true`, the script runs whether or not the document exists.
{
  "scripted_upsert": true,
  "script": {
    "source": """
      if ( ctx.op == 'create' ) {
        ctx._source.counter = params.count
      } else {
        ctx._source.counter += params.count
      }
    """,
    "params": {
      "count": 4
    }
  },
  "upsert": {}
}
Run `POST test/_update/1` to perform a doc as upsert. Instead of sending a partial `doc` plus an `upsert` doc, you can set `doc_as_upsert` to `true` to use the contents of `doc` as the `upsert` value.
{
  "doc": {
    "name": "new_name"
  },
  "doc_as_upsert": true
}
Response examples (200)
By default updates that don't change anything detect that they don't change anything and return `"result": "noop"`.
{
   "_shards": {
        "total": 0,
        "successful": 0,
        "failed": 0
   },
   "_index": "test",
   "_id": "1",
   "_version": 2,
   "_primary_term": 1,
   "_seq_no": 1,
   "result": "noop"
}



































































Stop async ES|QL query Added in 8.18.0

POST /_query/async/{id}/stop

This API interrupts the query execution and returns the results so far. If the Elasticsearch security features are enabled, only the user who first submitted the ES|QL query can stop it.

Path parameters

  • id string Required

    The unique identifier of the query. A query ID is provided in the ES|QL async query API response for a query that does not complete in the designated time. A query ID is also provided when the request was submitted with the keep_on_completion parameter set to true.

Query parameters

  • Indicates whether columns that are entirely null will be removed from the columns and values portion of the results. If true, the response will include an extra section under the name all_columns which has the name of all the columns.

Responses

  • 200 application/json

    Additional properties are allowed.

POST /_query/async/{id}/stop
curl \
 --request POST http://api.example.com/_query/async/{id}/stop
Response examples (200)
{}










































Graph explore

The graph explore API enables you to extract and summarize information about the documents and terms in an Elasticsearch data stream or index.


































Import a dangling index Added in 7.9.0

POST /_dangling/{index_uuid}

If Elasticsearch encounters index data that is absent from the current cluster state, those indices are considered to be dangling. For example, this can happen if you delete more than cluster.indices.tombstones.size indices while an Elasticsearch node is offline.

Path parameters

  • index_uuid string Required

    The UUID of the index to import. Use the get dangling indices API to locate the UUID.

Query parameters

  • accept_data_loss boolean Required

    This parameter must be set to true to import a dangling index. Because Elasticsearch cannot know where the dangling index data came from or determine which shard copies are fresh and which are stale, it cannot guarantee that the imported data represents the latest state of the index when it was last in the cluster.

  • Specify timeout for connection to master

  • timeout string

    Explicit operation timeout

Responses

  • 200 application/json
    Hide response attribute Show response attribute object
    • acknowledged boolean Required

      For a successful response, this value is always true. On failure, an exception is returned instead.

POST /_dangling/{index_uuid}
curl \
 --request POST http://api.example.com/_dangling/{index_uuid}?accept_data_loss=true
Response examples (200)
{
  "acknowledged": true
}












































Close an index

POST /{index}/_close

A closed index is blocked for read or write operations and does not allow all operations that opened indices allow. It is not possible to index documents or to search for documents in a closed index. Closed indices do not have to maintain internal data structures for indexing or searching documents, which results in a smaller overhead on the cluster.

When opening or closing an index, the master node is responsible for restarting the index shards to reflect the new state of the index. The shards will then go through the normal recovery process. The data of opened and closed indices is automatically replicated by the cluster to ensure that enough shard copies are safely kept around at all times.

You can open and close multiple indices. An error is thrown if the request explicitly refers to a missing index. This behaviour can be turned off using the ignore_unavailable=true parameter.

By default, you must explicitly name the indices you are opening or closing. To open or close indices with _all, *, or other wildcard expressions, change theaction.destructive_requires_name setting to false. This setting can also be changed with the cluster update settings API.

Closed indices consume a significant amount of disk-space which can cause problems in managed environments. Closing indices can be turned off with the cluster settings API by setting cluster.indices.close.enable to false.

Path parameters

  • index string | array[string] Required

    Comma-separated list or wildcard expression of index names used to limit the request.

Query parameters

  • If false, the request returns an error if any wildcard expression, index alias, or _all value targets only missing or closed indices. This behavior applies even if the request targets other open indices.

  • expand_wildcards string | array[string]

    Type of index that wildcard patterns can match. If the request can target data streams, this argument determines whether wildcard expressions match hidden data streams. Supports comma-separated values, such as open,hidden. Valid values are: all, open, closed, hidden, none.

  • If false, the request returns an error if it targets a missing or closed index.

  • Period to wait for a connection to the master node. If no response is received before the timeout expires, the request fails and returns an error.

  • timeout string

    Period to wait for a response. If no response is received before the timeout expires, the request fails and returns an error.

  • wait_for_active_shards number | string

    The number of shard copies that must be active before proceeding with the operation. Set to all or any positive integer up to the total number of shards in the index (number_of_replicas+1).

Responses

  • 200 application/json
    Hide response attributes Show response attributes object
    • acknowledged boolean Required
    • indices object Required
      Hide indices attribute Show indices attribute object
      • * object Additional properties

        Additional properties are allowed.

        Hide * attributes Show * attributes object
        • closed boolean Required
        • shards object
          Hide shards attribute Show shards attribute object
          • * object Additional properties

            Additional properties are allowed.

            Hide * attribute Show * attribute object
            • failures array[object] Required

              Additional properties are allowed.

    • shards_acknowledged boolean Required
POST /{index}/_close
curl \
 --request POST http://api.example.com/{index}/_close
Response examples (200)
A successful response for closing an index.
{
  "acknowledged": true,
  "shards_acknowledged": true,
  "indices": {
    "my-index-000001": {
      "closed": true
    }
  }
}
















































































Create or update an index template

POST /_template/{name}

Index templates define settings, mappings, and aliases that can be applied automatically to new indices. Elasticsearch applies templates to new indices based on an index pattern that matches the index name.

IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.

Composable templates always take precedence over legacy templates. If no composable template matches a new index, matching legacy templates are applied according to their order.

Index templates are only applied during index creation. Changes to index templates do not affect existing indices. Settings and mappings specified in create index API requests override any settings or mappings specified in an index template.

You can use C-style /* *\/ block comments in index templates. You can include comments anywhere in the request body, except before the opening curly bracket.

Indices matching multiple templates

Multiple index templates can potentially match an index, in this case, both the settings and mappings are merged into the final configuration of the index. The order of the merging can be controlled using the order parameter, with lower order being applied first, and higher orders overriding them. NOTE: Multiple matching templates with the same order value will result in a non-deterministic merging order.

Path parameters

  • name string Required

    The name of the template

Query parameters

  • create boolean

    If true, this request cannot replace or update existing index templates.

  • Period to wait for a connection to the master node. If no response is received before the timeout expires, the request fails and returns an error.

  • order number

    Order in which Elasticsearch applies this template if index matches multiple templates.

    Templates with lower 'order' values are merged first. Templates with higher 'order' values are merged later, overriding templates with lower values.

  • cause string
application/json

Body Required

  • aliases object

    Aliases for the index.

    Hide aliases attribute Show aliases attribute object
  • index_patterns string | array[string]

    Array of wildcard expressions used to match the names of indices during creation.

  • mappings object

    Additional properties are allowed.

    Hide mappings attributes Show mappings attributes object
  • order number

    Order in which Elasticsearch applies this template if index matches multiple templates.

    Templates with lower 'order' values are merged first. Templates with higher 'order' values are merged later, overriding templates with lower values.

  • settings object

    Additional properties are allowed.

    Hide settings attributes Show settings attributes object
    • index object

      Additional properties are allowed.

    • mode string
    • Additional properties are allowed.

      Hide soft_deletes attributes Show soft_deletes attributes object
      • enabled boolean

        Indicates whether soft deletes are enabled on the index.

      • Additional properties are allowed.

        Hide retention_lease attribute Show retention_lease attribute object
        • period string Required

          A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

    • sort object

      Additional properties are allowed.

      Hide sort attributes Show sort attributes object
    • Values are true, false, or checksum.

    • codec string
    • routing_partition_size number | string

      Some APIs will return values such as numbers also as a string (notably epoch timestamps). This behavior is used to capture this behavior while keeping the semantics of the field type.

      Depending on the target language, code generators can keep the union or remove it and leniently parse strings to the target type.

    • merge object

      Additional properties are allowed.

      Hide merge attribute Show merge attribute object
    • A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

    • blocks object

      Additional properties are allowed.

      Hide blocks attributes Show blocks attributes object
    • analyze object

      Additional properties are allowed.

      Hide analyze attribute Show analyze attribute object
    • Additional properties are allowed.

      Hide highlight attribute Show highlight attribute object
    • routing object

      Additional properties are allowed.

      Hide routing attributes Show routing attributes object
    • A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

    • Additional properties are allowed.

      Hide lifecycle attributes Show lifecycle attributes object
      • name string
      • indexing_complete boolean | string

        Some APIs will return values such as numbers also as a string (notably epoch timestamps). This behavior is used to capture this behavior while keeping the semantics of the field type.

        Depending on the target language, code generators can keep the union or remove it and leniently parse strings to the target type.

      • If specified, this is the timestamp used to calculate the index age for its phase transitions. Use this setting if you create a new index that contains old data and want to use the original creation date to calculate the index age. Specified as a Unix epoch value in milliseconds.

      • Set to true to parse the origination date from the index name. This origination date is used to calculate the index age for its phase transitions. The index name must match the pattern .*-{date_format}-\d+, where the date_format is yyyy.MM.dd and the trailing digits are optional. An index that was rolled over would normally match the full format, for example logs-2016.10.31-000002). If the index name doesn’t match the pattern, index creation fails.

      • step object

        Additional properties are allowed.

        Hide step attribute Show step attribute object
        • A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

      • The index alias to update when the index rolls over. Specify when using a policy that contains a rollover action. When the index rolls over, the alias is updated to reflect that the index is no longer the write index. For more information about rolling indices, see Rollover.

      • prefer_ilm boolean | string

        Preference for the system that manages a data stream backing index (preferring ILM when both ILM and DLM are applicable for an index).

    • creation_date number | string

      Some APIs will return values such as numbers also as a string (notably epoch timestamps). This behavior is used to capture this behavior while keeping the semantics of the field type.

      Depending on the target language, code generators can keep the union or remove it and leniently parse strings to the target type.

    • creation_date_string string | number

      A date and time, either as a string whose format can depend on the context (defaulting to ISO 8601), or a number of milliseconds since the Epoch. Elasticsearch accepts both as input, but will generally output a string representation.

    • uuid string
    • version object

      Additional properties are allowed.

      Hide version attributes Show version attributes object
    • translog object

      Additional properties are allowed.

      Hide translog attributes Show translog attributes object
    • Additional properties are allowed.

      Hide query_string attribute Show query_string attribute object
    • analysis object

      Additional properties are allowed.

      Hide analysis attributes Show analysis attributes object
    • settings object

      Additional properties are allowed.

    • Additional properties are allowed.

      Hide time_series attributes Show time_series attributes object
    • queries object

      Additional properties are allowed.

      Hide queries attribute Show queries attribute object
      • cache object

        Additional properties are allowed.

        Hide cache attribute Show cache attribute object
    • Configure custom similarity settings to customize how search results are scored.

    • mapping object

      Additional properties are allowed.

      Hide mapping attributes Show mapping attributes object
      • coerce boolean
      • Additional properties are allowed.

        Hide total_fields attributes Show total_fields attributes object
        • limit number | string

          The maximum number of fields in an index. Field and object mappings, as well as field aliases count towards this limit. The limit is in place to prevent mappings and searches from becoming too large. Higher values can lead to performance degradations and memory issues, especially in clusters with a high load or few resources.

        • ignore_dynamic_beyond_limit boolean | string

          This setting determines what happens when a dynamically mapped field would exceed the total fields limit. When set to false (the default), the index request of the document that tries to add a dynamic field to the mapping will fail with the message Limit of total fields [X] has been exceeded. When set to true, the index request will not fail. Instead, fields that would exceed the limit are not added to the mapping, similar to dynamic: false. The fields that were not added to the mapping will be added to the _ignored field.

      • depth object

        Additional properties are allowed.

        Hide depth attribute Show depth attribute object
        • limit number

          The maximum depth for a field, which is measured as the number of inner objects. For instance, if all fields are defined at the root object level, then the depth is 1. If there is one object mapping, then the depth is 2, etc.

      • Additional properties are allowed.

        Hide nested_fields attribute Show nested_fields attribute object
        • limit number

          The maximum number of distinct nested mappings in an index. The nested type should only be used in special cases, when arrays of objects need to be queried independently of each other. To safeguard against poorly designed mappings, this setting limits the number of unique nested types per index.

      • Additional properties are allowed.

        Hide nested_objects attribute Show nested_objects attribute object
        • limit number

          The maximum number of nested JSON objects that a single document can contain across all nested types. This limit helps to prevent out of memory errors when a document contains too many nested objects.

      • Additional properties are allowed.

        Hide field_name_length attribute Show field_name_length attribute object
        • limit number

          Setting for the maximum length of a field name. This setting isn’t really something that addresses mappings explosion but might still be useful if you want to limit the field length. It usually shouldn’t be necessary to set this setting. The default is okay unless a user starts to add a huge number of fields with really long names. Default is Long.MAX_VALUE (no limit).

      • Additional properties are allowed.

        Hide dimension_fields attribute Show dimension_fields attribute object
        • limit number

          [preview] This functionality is in technical preview and may be changed or removed in a future release. Elastic will work to fix any issues, but features in technical preview are not subject to the support SLA of official GA features.

      • source object

        Additional properties are allowed.

        Hide source attribute Show source attribute object
        • mode string Required

          Values are DISABLED, STORED, or SYNTHETIC.

    • Additional properties are allowed.

      Hide indexing.slowlog attributes Show indexing.slowlog attributes object
      • level string
      • source number
      • reformat boolean
      • Additional properties are allowed.

        Hide threshold attribute Show threshold attribute object
        • index object

          Additional properties are allowed.

          Hide index attributes Show index attributes object
          • warn string

            A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

          • info string

            A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

          • debug string

            A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

          • trace string

            A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

    • Additional properties are allowed.

      Hide indexing_pressure attribute Show indexing_pressure attribute object
      • memory object Required

        Additional properties are allowed.

        Hide memory attribute Show memory attribute object
        • limit number

          Number of outstanding bytes that may be consumed by indexing requests. When this limit is reached or exceeded, the node will reject new coordinating and primary operations. When replica operations consume 1.5x this limit, the node will reject new replica operations. Defaults to 10% of the heap.

    • store object

      Additional properties are allowed.

      Hide store attributes Show store attributes object
      • type string Required

      • allow_mmap boolean

        You can restrict the use of the mmapfs and the related hybridfs store type via the setting node.store.allow_mmap. This is a boolean setting indicating whether or not memory-mapping is allowed. The default is to allow it. This setting is useful, for example, if you are in an environment where you can not control the ability to create a lot of memory maps so you need disable the ability to use memory-mapping.

  • version number

Responses

  • 200 application/json
    Hide response attribute Show response attribute object
    • acknowledged boolean Required

      For a successful response, this value is always true. On failure, an exception is returned instead.

POST /_template/{name}
curl \
 --request POST http://api.example.com/_template/{name} \
 --header "Content-Type: application/json" \
 --data '{"mappings":{"_source":{"enabled":false}},"settings":{"number_of_shards":1},"properties":{"host_name":{"type":"keyword"},"created_at":{"type":"date","format":"EEE MMM dd HH:mm:ss Z yyyy"}},"index_patterns":["te*","bar*"]}'
Request example
{
  "mappings": {
    "_source": {
      "enabled": false
    }
  },
  "settings": {
    "number_of_shards": 1
  },
  "properties": {
    "host_name": {
      "type": "keyword"
    },
    "created_at": {
      "type": "date",
      "format": "EEE MMM dd HH:mm:ss Z yyyy"
    }
  },
  "index_patterns": [
    "te*",
    "bar*"
  ]
}
Response examples (200)
{
  "acknowledged": true
}




























































































































































































































Get index statistics Added in 1.3.0

GET /{index}/_stats

For data streams, the API retrieves statistics for the stream's backing indices.

By default, the returned statistics are index-level with primaries and total aggregations. primaries are the values for only the primary shards. total are the accumulated values for both primary and replica shards.

To get shard-level statistics, set the level parameter to shards.

NOTE: When moving to another node, the shard-level statistics for a shard are cleared. Although the shard is no longer part of the node, that node retains any node-level statistics to which the shard contributed.

Path parameters

  • index string | array[string] Required

    A comma-separated list of index names; use _all or empty string to perform the operation on all indices

Query parameters

  • completion_fields string | array[string]

    Comma-separated list or wildcard expressions of fields to include in fielddata and suggest statistics.

  • expand_wildcards string | array[string]

    Type of index that wildcard patterns can match. If the request can target data streams, this argument determines whether wildcard expressions match hidden data streams. Supports comma-separated values, such as open,hidden.

  • fielddata_fields string | array[string]

    Comma-separated list or wildcard expressions of fields to include in fielddata statistics.

  • fields string | array[string]

    Comma-separated list or wildcard expressions of fields to include in the statistics.

  • If true, statistics are not collected from closed indices.

  • groups string | array[string]

    Comma-separated list of search groups to include in the search statistics.

  • If true, the call reports the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested).

  • If true, the response includes information from segments that are not loaded into memory.

  • level string

    Indicates whether statistics are aggregated at the cluster, index, or shard level.

    Values are cluster, indices, or shards.

Responses

GET /{index}/_stats
curl \
 --request GET http://api.example.com/{index}/_stats
Response examples (200)
{
  "indices": {
    "additionalProperty1": {
      "primaries": {
        "completion": {
          "size_in_bytes": 42.0,
          "": 42.0,
          "fields": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "docs": {
          "count": 42.0,
          "deleted": 42.0
        },
        "fielddata": {
          "evictions": 42.0,
          "": 42.0,
          "memory_size_in_bytes": 42.0,
          "fields": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "flush": {
          "periodic": 42.0,
          "total": 42.0,
          "total_time": "string",
          "": 42.0
        },
        "get": {
          "current": 42.0,
          "exists_time": "string",
          "": 42.0,
          "exists_total": 42.0,
          "missing_time": "string",
          "missing_total": 42.0,
          "time": "string",
          "total": 42.0
        },
        "indexing": {
          "index_current": 42.0,
          "delete_current": 42.0,
          "delete_time": "string",
          "": 42.0,
          "delete_total": 42.0,
          "is_throttled": true,
          "noop_update_total": 42.0,
          "throttle_time": "string",
          "index_time": "string",
          "index_total": 42.0,
          "index_failed": 42.0,
          "types": {
            "*": {}
          },
          "write_load": 42.0
        },
        "additionalProperty1": {},
        "additionalProperty2": {},
        "merges": {
          "current": 42.0,
          "current_docs": 42.0,
          "current_size": "string",
          "current_size_in_bytes": 42.0,
          "total": 42.0,
          "total_auto_throttle": "string",
          "total_auto_throttle_in_bytes": 42.0,
          "total_docs": 42.0,
          "total_size": "string",
          "total_size_in_bytes": 42.0,
          "total_stopped_time": "string",
          "": 42.0,
          "total_throttled_time": "string",
          "total_time": "string"
        },
        "query_cache": {
          "cache_count": 42.0,
          "cache_size": 42.0,
          "evictions": 42.0,
          "hit_count": 42.0,
          "": 42.0,
          "memory_size_in_bytes": 42.0,
          "miss_count": 42.0,
          "total_count": 42.0
        },
        "recovery": {
          "current_as_source": 42.0,
          "current_as_target": 42.0,
          "throttle_time": "string",
          "": 42.0
        },
        "refresh": {
          "external_total": 42.0,
          "": 42.0,
          "listeners": 42.0,
          "total": 42.0,
          "total_time": "string"
        },
        "request_cache": {
          "evictions": 42.0,
          "hit_count": 42.0,
          "memory_size": "string",
          "memory_size_in_bytes": 42.0,
          "miss_count": 42.0
        },
        "search": {
          "fetch_current": 42.0,
          "fetch_time": "string",
          "": 42.0,
          "fetch_total": 42.0,
          "open_contexts": 42.0,
          "query_current": 42.0,
          "query_time": "string",
          "query_total": 42.0,
          "scroll_current": 42.0,
          "scroll_time": "string",
          "scroll_total": 42.0,
          "suggest_current": 42.0,
          "suggest_time": "string",
          "suggest_total": 42.0,
          "groups": {
            "*": {}
          }
        },
        "segments": {
          "count": 42.0,
          "": 42.0,
          "doc_values_memory_in_bytes": 42.0,
          "file_sizes": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          },
          "fixed_bit_set_memory_in_bytes": 42.0,
          "index_writer_max_memory_in_bytes": 42.0,
          "index_writer_memory_in_bytes": 42.0,
          "max_unsafe_auto_id_timestamp": 42.0,
          "memory_in_bytes": 42.0,
          "norms_memory_in_bytes": 42.0,
          "points_memory_in_bytes": 42.0,
          "stored_fields_memory_in_bytes": 42.0,
          "terms_memory_in_bytes": 42.0,
          "term_vectors_memory_in_bytes": 42.0,
          "version_map_memory_in_bytes": 42.0
        },
        "store": {
          "": 42.0,
          "size_in_bytes": 42.0,
          "reserved_in_bytes": 42.0,
          "total_data_set_size_in_bytes": 42.0
        },
        "translog": {
          "earliest_last_modified_age": 42.0,
          "operations": 42.0,
          "size": "string",
          "size_in_bytes": 42.0,
          "uncommitted_operations": 42.0,
          "uncommitted_size": "string",
          "uncommitted_size_in_bytes": 42.0
        },
        "warmer": {
          "current": 42.0,
          "total": 42.0,
          "total_time": "string",
          "": 42.0
        },
        "bulk": {
          "total_operations": 42.0,
          "total_time": "string",
          "": 42.0,
          "total_size_in_bytes": 42.0,
          "avg_time": "string",
          "avg_size_in_bytes": 42.0
        },
        "shard_stats": {
          "total_count": 42.0
        }
      },
      "shards": {
        "additionalProperty1": [
          {
            "commit": {},
            "completion": {},
            "docs": {},
            "fielddata": {},
            "flush": {},
            "get": {},
            "indexing": {},
            "mappings": {},
            "merges": {},
            "shard_path": {},
            "query_cache": {},
            "recovery": {},
            "refresh": {},
            "request_cache": {},
            "retention_leases": {},
            "routing": {},
            "search": {},
            "segments": {},
            "seq_no": {},
            "store": {},
            "translog": {},
            "warmer": {},
            "bulk": {},
            "shards": {},
            "shard_stats": {},
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        ],
        "additionalProperty2": [
          {
            "commit": {},
            "completion": {},
            "docs": {},
            "fielddata": {},
            "flush": {},
            "get": {},
            "indexing": {},
            "mappings": {},
            "merges": {},
            "shard_path": {},
            "query_cache": {},
            "recovery": {},
            "refresh": {},
            "request_cache": {},
            "retention_leases": {},
            "routing": {},
            "search": {},
            "segments": {},
            "seq_no": {},
            "store": {},
            "translog": {},
            "warmer": {},
            "bulk": {},
            "shards": {},
            "shard_stats": {},
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        ]
      },
      "total": {
        "completion": {
          "size_in_bytes": 42.0,
          "": 42.0,
          "fields": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "docs": {
          "count": 42.0,
          "deleted": 42.0
        },
        "fielddata": {
          "evictions": 42.0,
          "": 42.0,
          "memory_size_in_bytes": 42.0,
          "fields": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "flush": {
          "periodic": 42.0,
          "total": 42.0,
          "total_time": "string",
          "": 42.0
        },
        "get": {
          "current": 42.0,
          "exists_time": "string",
          "": 42.0,
          "exists_total": 42.0,
          "missing_time": "string",
          "missing_total": 42.0,
          "time": "string",
          "total": 42.0
        },
        "indexing": {
          "index_current": 42.0,
          "delete_current": 42.0,
          "delete_time": "string",
          "": 42.0,
          "delete_total": 42.0,
          "is_throttled": true,
          "noop_update_total": 42.0,
          "throttle_time": "string",
          "index_time": "string",
          "index_total": 42.0,
          "index_failed": 42.0,
          "types": {
            "*": {}
          },
          "write_load": 42.0
        },
        "additionalProperty1": {},
        "additionalProperty2": {},
        "merges": {
          "current": 42.0,
          "current_docs": 42.0,
          "current_size": "string",
          "current_size_in_bytes": 42.0,
          "total": 42.0,
          "total_auto_throttle": "string",
          "total_auto_throttle_in_bytes": 42.0,
          "total_docs": 42.0,
          "total_size": "string",
          "total_size_in_bytes": 42.0,
          "total_stopped_time": "string",
          "": 42.0,
          "total_throttled_time": "string",
          "total_time": "string"
        },
        "query_cache": {
          "cache_count": 42.0,
          "cache_size": 42.0,
          "evictions": 42.0,
          "hit_count": 42.0,
          "": 42.0,
          "memory_size_in_bytes": 42.0,
          "miss_count": 42.0,
          "total_count": 42.0
        },
        "recovery": {
          "current_as_source": 42.0,
          "current_as_target": 42.0,
          "throttle_time": "string",
          "": 42.0
        },
        "refresh": {
          "external_total": 42.0,
          "": 42.0,
          "listeners": 42.0,
          "total": 42.0,
          "total_time": "string"
        },
        "request_cache": {
          "evictions": 42.0,
          "hit_count": 42.0,
          "memory_size": "string",
          "memory_size_in_bytes": 42.0,
          "miss_count": 42.0
        },
        "search": {
          "fetch_current": 42.0,
          "fetch_time": "string",
          "": 42.0,
          "fetch_total": 42.0,
          "open_contexts": 42.0,
          "query_current": 42.0,
          "query_time": "string",
          "query_total": 42.0,
          "scroll_current": 42.0,
          "scroll_time": "string",
          "scroll_total": 42.0,
          "suggest_current": 42.0,
          "suggest_time": "string",
          "suggest_total": 42.0,
          "groups": {
            "*": {}
          }
        },
        "segments": {
          "count": 42.0,
          "": 42.0,
          "doc_values_memory_in_bytes": 42.0,
          "file_sizes": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          },
          "fixed_bit_set_memory_in_bytes": 42.0,
          "index_writer_max_memory_in_bytes": 42.0,
          "index_writer_memory_in_bytes": 42.0,
          "max_unsafe_auto_id_timestamp": 42.0,
          "memory_in_bytes": 42.0,
          "norms_memory_in_bytes": 42.0,
          "points_memory_in_bytes": 42.0,
          "stored_fields_memory_in_bytes": 42.0,
          "terms_memory_in_bytes": 42.0,
          "term_vectors_memory_in_bytes": 42.0,
          "version_map_memory_in_bytes": 42.0
        },
        "store": {
          "": 42.0,
          "size_in_bytes": 42.0,
          "reserved_in_bytes": 42.0,
          "total_data_set_size_in_bytes": 42.0
        },
        "translog": {
          "earliest_last_modified_age": 42.0,
          "operations": 42.0,
          "size": "string",
          "size_in_bytes": 42.0,
          "uncommitted_operations": 42.0,
          "uncommitted_size": "string",
          "uncommitted_size_in_bytes": 42.0
        },
        "warmer": {
          "current": 42.0,
          "total": 42.0,
          "total_time": "string",
          "": 42.0
        },
        "bulk": {
          "total_operations": 42.0,
          "total_time": "string",
          "": 42.0,
          "total_size_in_bytes": 42.0,
          "avg_time": "string",
          "avg_size_in_bytes": 42.0
        },
        "shard_stats": {
          "total_count": 42.0
        }
      },
      "uuid": "string",
      "health": "green",
      "status": "open"
    },
    "additionalProperty2": {
      "primaries": {
        "completion": {
          "size_in_bytes": 42.0,
          "": 42.0,
          "fields": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "docs": {
          "count": 42.0,
          "deleted": 42.0
        },
        "fielddata": {
          "evictions": 42.0,
          "": 42.0,
          "memory_size_in_bytes": 42.0,
          "fields": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "flush": {
          "periodic": 42.0,
          "total": 42.0,
          "total_time": "string",
          "": 42.0
        },
        "get": {
          "current": 42.0,
          "exists_time": "string",
          "": 42.0,
          "exists_total": 42.0,
          "missing_time": "string",
          "missing_total": 42.0,
          "time": "string",
          "total": 42.0
        },
        "indexing": {
          "index_current": 42.0,
          "delete_current": 42.0,
          "delete_time": "string",
          "": 42.0,
          "delete_total": 42.0,
          "is_throttled": true,
          "noop_update_total": 42.0,
          "throttle_time": "string",
          "index_time": "string",
          "index_total": 42.0,
          "index_failed": 42.0,
          "types": {
            "*": {}
          },
          "write_load": 42.0
        },
        "additionalProperty1": {},
        "additionalProperty2": {},
        "merges": {
          "current": 42.0,
          "current_docs": 42.0,
          "current_size": "string",
          "current_size_in_bytes": 42.0,
          "total": 42.0,
          "total_auto_throttle": "string",
          "total_auto_throttle_in_bytes": 42.0,
          "total_docs": 42.0,
          "total_size": "string",
          "total_size_in_bytes": 42.0,
          "total_stopped_time": "string",
          "": 42.0,
          "total_throttled_time": "string",
          "total_time": "string"
        },
        "query_cache": {
          "cache_count": 42.0,
          "cache_size": 42.0,
          "evictions": 42.0,
          "hit_count": 42.0,
          "": 42.0,
          "memory_size_in_bytes": 42.0,
          "miss_count": 42.0,
          "total_count": 42.0
        },
        "recovery": {
          "current_as_source": 42.0,
          "current_as_target": 42.0,
          "throttle_time": "string",
          "": 42.0
        },
        "refresh": {
          "external_total": 42.0,
          "": 42.0,
          "listeners": 42.0,
          "total": 42.0,
          "total_time": "string"
        },
        "request_cache": {
          "evictions": 42.0,
          "hit_count": 42.0,
          "memory_size": "string",
          "memory_size_in_bytes": 42.0,
          "miss_count": 42.0
        },
        "search": {
          "fetch_current": 42.0,
          "fetch_time": "string",
          "": 42.0,
          "fetch_total": 42.0,
          "open_contexts": 42.0,
          "query_current": 42.0,
          "query_time": "string",
          "query_total": 42.0,
          "scroll_current": 42.0,
          "scroll_time": "string",
          "scroll_total": 42.0,
          "suggest_current": 42.0,
          "suggest_time": "string",
          "suggest_total": 42.0,
          "groups": {
            "*": {}
          }
        },
        "segments": {
          "count": 42.0,
          "": 42.0,
          "doc_values_memory_in_bytes": 42.0,
          "file_sizes": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          },
          "fixed_bit_set_memory_in_bytes": 42.0,
          "index_writer_max_memory_in_bytes": 42.0,
          "index_writer_memory_in_bytes": 42.0,
          "max_unsafe_auto_id_timestamp": 42.0,
          "memory_in_bytes": 42.0,
          "norms_memory_in_bytes": 42.0,
          "points_memory_in_bytes": 42.0,
          "stored_fields_memory_in_bytes": 42.0,
          "terms_memory_in_bytes": 42.0,
          "term_vectors_memory_in_bytes": 42.0,
          "version_map_memory_in_bytes": 42.0
        },
        "store": {
          "": 42.0,
          "size_in_bytes": 42.0,
          "reserved_in_bytes": 42.0,
          "total_data_set_size_in_bytes": 42.0
        },
        "translog": {
          "earliest_last_modified_age": 42.0,
          "operations": 42.0,
          "size": "string",
          "size_in_bytes": 42.0,
          "uncommitted_operations": 42.0,
          "uncommitted_size": "string",
          "uncommitted_size_in_bytes": 42.0
        },
        "warmer": {
          "current": 42.0,
          "total": 42.0,
          "total_time": "string",
          "": 42.0
        },
        "bulk": {
          "total_operations": 42.0,
          "total_time": "string",
          "": 42.0,
          "total_size_in_bytes": 42.0,
          "avg_time": "string",
          "avg_size_in_bytes": 42.0
        },
        "shard_stats": {
          "total_count": 42.0
        }
      },
      "shards": {
        "additionalProperty1": [
          {
            "commit": {},
            "completion": {},
            "docs": {},
            "fielddata": {},
            "flush": {},
            "get": {},
            "indexing": {},
            "mappings": {},
            "merges": {},
            "shard_path": {},
            "query_cache": {},
            "recovery": {},
            "refresh": {},
            "request_cache": {},
            "retention_leases": {},
            "routing": {},
            "search": {},
            "segments": {},
            "seq_no": {},
            "store": {},
            "translog": {},
            "warmer": {},
            "bulk": {},
            "shards": {},
            "shard_stats": {},
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        ],
        "additionalProperty2": [
          {
            "commit": {},
            "completion": {},
            "docs": {},
            "fielddata": {},
            "flush": {},
            "get": {},
            "indexing": {},
            "mappings": {},
            "merges": {},
            "shard_path": {},
            "query_cache": {},
            "recovery": {},
            "refresh": {},
            "request_cache": {},
            "retention_leases": {},
            "routing": {},
            "search": {},
            "segments": {},
            "seq_no": {},
            "store": {},
            "translog": {},
            "warmer": {},
            "bulk": {},
            "shards": {},
            "shard_stats": {},
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        ]
      },
      "total": {
        "completion": {
          "size_in_bytes": 42.0,
          "": 42.0,
          "fields": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "docs": {
          "count": 42.0,
          "deleted": 42.0
        },
        "fielddata": {
          "evictions": 42.0,
          "": 42.0,
          "memory_size_in_bytes": 42.0,
          "fields": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          }
        },
        "flush": {
          "periodic": 42.0,
          "total": 42.0,
          "total_time": "string",
          "": 42.0
        },
        "get": {
          "current": 42.0,
          "exists_time": "string",
          "": 42.0,
          "exists_total": 42.0,
          "missing_time": "string",
          "missing_total": 42.0,
          "time": "string",
          "total": 42.0
        },
        "indexing": {
          "index_current": 42.0,
          "delete_current": 42.0,
          "delete_time": "string",
          "": 42.0,
          "delete_total": 42.0,
          "is_throttled": true,
          "noop_update_total": 42.0,
          "throttle_time": "string",
          "index_time": "string",
          "index_total": 42.0,
          "index_failed": 42.0,
          "types": {
            "*": {}
          },
          "write_load": 42.0
        },
        "additionalProperty1": {},
        "additionalProperty2": {},
        "merges": {
          "current": 42.0,
          "current_docs": 42.0,
          "current_size": "string",
          "current_size_in_bytes": 42.0,
          "total": 42.0,
          "total_auto_throttle": "string",
          "total_auto_throttle_in_bytes": 42.0,
          "total_docs": 42.0,
          "total_size": "string",
          "total_size_in_bytes": 42.0,
          "total_stopped_time": "string",
          "": 42.0,
          "total_throttled_time": "string",
          "total_time": "string"
        },
        "query_cache": {
          "cache_count": 42.0,
          "cache_size": 42.0,
          "evictions": 42.0,
          "hit_count": 42.0,
          "": 42.0,
          "memory_size_in_bytes": 42.0,
          "miss_count": 42.0,
          "total_count": 42.0
        },
        "recovery": {
          "current_as_source": 42.0,
          "current_as_target": 42.0,
          "throttle_time": "string",
          "": 42.0
        },
        "refresh": {
          "external_total": 42.0,
          "": 42.0,
          "listeners": 42.0,
          "total": 42.0,
          "total_time": "string"
        },
        "request_cache": {
          "evictions": 42.0,
          "hit_count": 42.0,
          "memory_size": "string",
          "memory_size_in_bytes": 42.0,
          "miss_count": 42.0
        },
        "search": {
          "fetch_current": 42.0,
          "fetch_time": "string",
          "": 42.0,
          "fetch_total": 42.0,
          "open_contexts": 42.0,
          "query_current": 42.0,
          "query_time": "string",
          "query_total": 42.0,
          "scroll_current": 42.0,
          "scroll_time": "string",
          "scroll_total": 42.0,
          "suggest_current": 42.0,
          "suggest_time": "string",
          "suggest_total": 42.0,
          "groups": {
            "*": {}
          }
        },
        "segments": {
          "count": 42.0,
          "": 42.0,
          "doc_values_memory_in_bytes": 42.0,
          "file_sizes": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          },
          "fixed_bit_set_memory_in_bytes": 42.0,
          "index_writer_max_memory_in_bytes": 42.0,
          "index_writer_memory_in_bytes": 42.0,
          "max_unsafe_auto_id_timestamp": 42.0,
          "memory_in_bytes": 42.0,
          "norms_memory_in_bytes": 42.0,
          "points_memory_in_bytes": 42.0,
          "stored_fields_memory_in_bytes": 42.0,
          "terms_memory_in_bytes": 42.0,
          "term_vectors_memory_in_bytes": 42.0,
          "version_map_memory_in_bytes": 42.0
        },
        "store": {
          "": 42.0,
          "size_in_bytes": 42.0,
          "reserved_in_bytes": 42.0,
          "total_data_set_size_in_bytes": 42.0
        },
        "translog": {
          "earliest_last_modified_age": 42.0,
          "operations": 42.0,
          "size": "string",
          "size_in_bytes": 42.0,
          "uncommitted_operations": 42.0,
          "uncommitted_size": "string",
          "uncommitted_size_in_bytes": 42.0
        },
        "warmer": {
          "current": 42.0,
          "total": 42.0,
          "total_time": "string",
          "": 42.0
        },
        "bulk": {
          "total_operations": 42.0,
          "total_time": "string",
          "": 42.0,
          "total_size_in_bytes": 42.0,
          "avg_time": "string",
          "avg_size_in_bytes": 42.0
        },
        "shard_stats": {
          "total_count": 42.0
        }
      },
      "uuid": "string",
      "health": "green",
      "status": "open"
    }
  },
  "_shards": {
    "failed": 42.0,
    "successful": 42.0,
    "total": 42.0,
    "failures": [
      {
        "index": "string",
        "node": "string",
        "reason": {
          "type": "string",
          "reason": "string",
          "stack_trace": "string",
          "caused_by": {},
          "root_cause": [
            {}
          ],
          "suppressed": [
            {}
          ]
        },
        "shard": 42.0,
        "status": "string"
      }
    ],
    "skipped": 42.0
  },
  "additionalProperty1": {
    "primaries": {
      "completion": {
        "size_in_bytes": 42.0,
        "": 42.0,
        "fields": {
          "additionalProperty1": {
            "size_in_bytes": 42.0
          },
          "additionalProperty2": {
            "size_in_bytes": 42.0
          }
        }
      },
      "docs": {
        "count": 42.0,
        "deleted": 42.0
      },
      "fielddata": {
        "evictions": 42.0,
        "": 42.0,
        "memory_size_in_bytes": 42.0,
        "fields": {
          "additionalProperty1": {
            "memory_size_in_bytes": 42.0
          },
          "additionalProperty2": {
            "memory_size_in_bytes": 42.0
          }
        }
      },
      "flush": {
        "periodic": 42.0,
        "total": 42.0,
        "total_time": "string",
        "": 42.0
      },
      "get": {
        "current": 42.0,
        "exists_time": "string",
        "": 42.0,
        "exists_total": 42.0,
        "missing_time": "string",
        "missing_total": 42.0,
        "time": "string",
        "total": 42.0
      },
      "indexing": {
        "index_current": 42.0,
        "delete_current": 42.0,
        "delete_time": "string",
        "": 42.0,
        "delete_total": 42.0,
        "is_throttled": true,
        "noop_update_total": 42.0,
        "throttle_time": "string",
        "index_time": "string",
        "index_total": 42.0,
        "index_failed": 42.0,
        "types": {
          "*": {}
        },
        "write_load": 42.0
      },
      "additionalProperty1": {},
      "additionalProperty2": {},
      "merges": {
        "current": 42.0,
        "current_docs": 42.0,
        "current_size": "string",
        "current_size_in_bytes": 42.0,
        "total": 42.0,
        "total_auto_throttle": "string",
        "total_auto_throttle_in_bytes": 42.0,
        "total_docs": 42.0,
        "total_size": "string",
        "total_size_in_bytes": 42.0,
        "total_stopped_time": "string",
        "": 42.0,
        "total_throttled_time": "string",
        "total_time": "string"
      },
      "query_cache": {
        "cache_count": 42.0,
        "cache_size": 42.0,
        "evictions": 42.0,
        "hit_count": 42.0,
        "": 42.0,
        "memory_size_in_bytes": 42.0,
        "miss_count": 42.0,
        "total_count": 42.0
      },
      "recovery": {
        "current_as_source": 42.0,
        "current_as_target": 42.0,
        "throttle_time": "string",
        "": 42.0
      },
      "refresh": {
        "external_total": 42.0,
        "": 42.0,
        "listeners": 42.0,
        "total": 42.0,
        "total_time": "string"
      },
      "request_cache": {
        "evictions": 42.0,
        "hit_count": 42.0,
        "memory_size": "string",
        "memory_size_in_bytes": 42.0,
        "miss_count": 42.0
      },
      "search": {
        "fetch_current": 42.0,
        "fetch_time": "string",
        "": 42.0,
        "fetch_total": 42.0,
        "open_contexts": 42.0,
        "query_current": 42.0,
        "query_time": "string",
        "query_total": 42.0,
        "scroll_current": 42.0,
        "scroll_time": "string",
        "scroll_total": 42.0,
        "suggest_current": 42.0,
        "suggest_time": "string",
        "suggest_total": 42.0,
        "groups": {
          "*": {}
        }
      },
      "segments": {
        "count": 42.0,
        "": 42.0,
        "doc_values_memory_in_bytes": 42.0,
        "file_sizes": {
          "additionalProperty1": {
            "description": "string",
            "size_in_bytes": 42.0,
            "min_size_in_bytes": 42.0,
            "max_size_in_bytes": 42.0,
            "average_size_in_bytes": 42.0,
            "count": 42.0
          },
          "additionalProperty2": {
            "description": "string",
            "size_in_bytes": 42.0,
            "min_size_in_bytes": 42.0,
            "max_size_in_bytes": 42.0,
            "average_size_in_bytes": 42.0,
            "count": 42.0
          }
        },
        "fixed_bit_set_memory_in_bytes": 42.0,
        "index_writer_max_memory_in_bytes": 42.0,
        "index_writer_memory_in_bytes": 42.0,
        "max_unsafe_auto_id_timestamp": 42.0,
        "memory_in_bytes": 42.0,
        "norms_memory_in_bytes": 42.0,
        "points_memory_in_bytes": 42.0,
        "stored_fields_memory_in_bytes": 42.0,
        "terms_memory_in_bytes": 42.0,
        "term_vectors_memory_in_bytes": 42.0,
        "version_map_memory_in_bytes": 42.0
      },
      "store": {
        "": 42.0,
        "size_in_bytes": 42.0,
        "reserved_in_bytes": 42.0,
        "total_data_set_size_in_bytes": 42.0
      },
      "translog": {
        "earliest_last_modified_age": 42.0,
        "operations": 42.0,
        "size": "string",
        "size_in_bytes": 42.0,
        "uncommitted_operations": 42.0,
        "uncommitted_size": "string",
        "uncommitted_size_in_bytes": 42.0
      },
      "warmer": {
        "current": 42.0,
        "total": 42.0,
        "total_time": "string",
        "": 42.0
      },
      "bulk": {
        "total_operations": 42.0,
        "total_time": "string",
        "": 42.0,
        "total_size_in_bytes": 42.0,
        "avg_time": "string",
        "avg_size_in_bytes": 42.0
      },
      "shard_stats": {
        "total_count": 42.0
      }
    },
    "shards": {
      "additionalProperty1": [
        {
          "commit": {
            "generation": 42.0,
            "id": "string",
            "num_docs": 42.0,
            "user_data": {}
          },
          "completion": {
            "size_in_bytes": 42.0,
            "fields": {}
          },
          "docs": {
            "count": 42.0,
            "deleted": 42.0
          },
          "fielddata": {
            "evictions": 42.0,
            "memory_size_in_bytes": 42.0,
            "fields": {}
          },
          "flush": {
            "periodic": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "get": {
            "current": 42.0,
            "exists_time": "string",
            "exists_total": 42.0,
            "missing_time": "string",
            "missing_total": 42.0,
            "time": "string",
            "total": 42.0
          },
          "indexing": {
            "index_current": 42.0,
            "delete_current": 42.0,
            "delete_time": "string",
            "delete_total": 42.0,
            "is_throttled": true,
            "noop_update_total": 42.0,
            "throttle_time": "string",
            "index_time": "string",
            "index_total": 42.0,
            "index_failed": 42.0,
            "types": {},
            "write_load": 42.0
          },
          "mappings": {
            "total_count": 42.0,
            "total_estimated_overhead_in_bytes": 42.0
          },
          "merges": {
            "current": 42.0,
            "current_docs": 42.0,
            "current_size": "string",
            "current_size_in_bytes": 42.0,
            "total": 42.0,
            "total_auto_throttle": "string",
            "total_auto_throttle_in_bytes": 42.0,
            "total_docs": 42.0,
            "total_size": "string",
            "total_size_in_bytes": 42.0,
            "total_stopped_time": "string",
            "total_throttled_time": "string",
            "total_time": "string"
          },
          "shard_path": {
            "data_path": "string",
            "is_custom_data_path": true,
            "state_path": "string"
          },
          "query_cache": {
            "cache_count": 42.0,
            "cache_size": 42.0,
            "evictions": 42.0,
            "hit_count": 42.0,
            "memory_size_in_bytes": 42.0,
            "miss_count": 42.0,
            "total_count": 42.0
          },
          "recovery": {
            "current_as_source": 42.0,
            "current_as_target": 42.0,
            "throttle_time": "string"
          },
          "refresh": {
            "external_total": 42.0,
            "listeners": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "request_cache": {
            "evictions": 42.0,
            "hit_count": 42.0,
            "memory_size": "string",
            "memory_size_in_bytes": 42.0,
            "miss_count": 42.0
          },
          "retention_leases": {
            "primary_term": 42.0,
            "version": 42.0,
            "leases": [
              {}
            ]
          },
          "routing": {
            "node": "string",
            "primary": true,
            "state": "UNASSIGNED"
          },
          "search": {
            "fetch_current": 42.0,
            "fetch_time": "string",
            "fetch_total": 42.0,
            "open_contexts": 42.0,
            "query_current": 42.0,
            "query_time": "string",
            "query_total": 42.0,
            "scroll_current": 42.0,
            "scroll_time": "string",
            "scroll_total": 42.0,
            "suggest_current": 42.0,
            "suggest_time": "string",
            "suggest_total": 42.0,
            "groups": {}
          },
          "segments": {
            "count": 42.0,
            "doc_values_memory_in_bytes": 42.0,
            "file_sizes": {},
            "fixed_bit_set_memory_in_bytes": 42.0,
            "index_writer_max_memory_in_bytes": 42.0,
            "index_writer_memory_in_bytes": 42.0,
            "max_unsafe_auto_id_timestamp": 42.0,
            "memory_in_bytes": 42.0,
            "norms_memory_in_bytes": 42.0,
            "points_memory_in_bytes": 42.0,
            "stored_fields_memory_in_bytes": 42.0,
            "terms_memory_in_bytes": 42.0,
            "term_vectors_memory_in_bytes": 42.0,
            "version_map_memory_in_bytes": 42.0
          },
          "seq_no": {
            "global_checkpoint": 42.0,
            "local_checkpoint": 42.0,
            "max_seq_no": 42.0
          },
          "store": {
            "size_in_bytes": 42.0,
            "reserved_in_bytes": 42.0,
            "total_data_set_size_in_bytes": 42.0
          },
          "translog": {
            "earliest_last_modified_age": 42.0,
            "operations": 42.0,
            "size": "string",
            "size_in_bytes": 42.0,
            "uncommitted_operations": 42.0,
            "uncommitted_size": "string",
            "uncommitted_size_in_bytes": 42.0
          },
          "warmer": {
            "current": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "bulk": {
            "total_operations": 42.0,
            "total_time": "string",
            "total_size_in_bytes": 42.0,
            "avg_time": "string",
            "avg_size_in_bytes": 42.0
          },
          "shards": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          },
          "shard_stats": {
            "total_count": 42.0
          },
          "additionalProperty1": {},
          "additionalProperty2": {}
        }
      ],
      "additionalProperty2": [
        {
          "commit": {
            "generation": 42.0,
            "id": "string",
            "num_docs": 42.0,
            "user_data": {}
          },
          "completion": {
            "size_in_bytes": 42.0,
            "fields": {}
          },
          "docs": {
            "count": 42.0,
            "deleted": 42.0
          },
          "fielddata": {
            "evictions": 42.0,
            "memory_size_in_bytes": 42.0,
            "fields": {}
          },
          "flush": {
            "periodic": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "get": {
            "current": 42.0,
            "exists_time": "string",
            "exists_total": 42.0,
            "missing_time": "string",
            "missing_total": 42.0,
            "time": "string",
            "total": 42.0
          },
          "indexing": {
            "index_current": 42.0,
            "delete_current": 42.0,
            "delete_time": "string",
            "delete_total": 42.0,
            "is_throttled": true,
            "noop_update_total": 42.0,
            "throttle_time": "string",
            "index_time": "string",
            "index_total": 42.0,
            "index_failed": 42.0,
            "types": {},
            "write_load": 42.0
          },
          "mappings": {
            "total_count": 42.0,
            "total_estimated_overhead_in_bytes": 42.0
          },
          "merges": {
            "current": 42.0,
            "current_docs": 42.0,
            "current_size": "string",
            "current_size_in_bytes": 42.0,
            "total": 42.0,
            "total_auto_throttle": "string",
            "total_auto_throttle_in_bytes": 42.0,
            "total_docs": 42.0,
            "total_size": "string",
            "total_size_in_bytes": 42.0,
            "total_stopped_time": "string",
            "total_throttled_time": "string",
            "total_time": "string"
          },
          "shard_path": {
            "data_path": "string",
            "is_custom_data_path": true,
            "state_path": "string"
          },
          "query_cache": {
            "cache_count": 42.0,
            "cache_size": 42.0,
            "evictions": 42.0,
            "hit_count": 42.0,
            "memory_size_in_bytes": 42.0,
            "miss_count": 42.0,
            "total_count": 42.0
          },
          "recovery": {
            "current_as_source": 42.0,
            "current_as_target": 42.0,
            "throttle_time": "string"
          },
          "refresh": {
            "external_total": 42.0,
            "listeners": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "request_cache": {
            "evictions": 42.0,
            "hit_count": 42.0,
            "memory_size": "string",
            "memory_size_in_bytes": 42.0,
            "miss_count": 42.0
          },
          "retention_leases": {
            "primary_term": 42.0,
            "version": 42.0,
            "leases": [
              {}
            ]
          },
          "routing": {
            "node": "string",
            "primary": true,
            "state": "UNASSIGNED"
          },
          "search": {
            "fetch_current": 42.0,
            "fetch_time": "string",
            "fetch_total": 42.0,
            "open_contexts": 42.0,
            "query_current": 42.0,
            "query_time": "string",
            "query_total": 42.0,
            "scroll_current": 42.0,
            "scroll_time": "string",
            "scroll_total": 42.0,
            "suggest_current": 42.0,
            "suggest_time": "string",
            "suggest_total": 42.0,
            "groups": {}
          },
          "segments": {
            "count": 42.0,
            "doc_values_memory_in_bytes": 42.0,
            "file_sizes": {},
            "fixed_bit_set_memory_in_bytes": 42.0,
            "index_writer_max_memory_in_bytes": 42.0,
            "index_writer_memory_in_bytes": 42.0,
            "max_unsafe_auto_id_timestamp": 42.0,
            "memory_in_bytes": 42.0,
            "norms_memory_in_bytes": 42.0,
            "points_memory_in_bytes": 42.0,
            "stored_fields_memory_in_bytes": 42.0,
            "terms_memory_in_bytes": 42.0,
            "term_vectors_memory_in_bytes": 42.0,
            "version_map_memory_in_bytes": 42.0
          },
          "seq_no": {
            "global_checkpoint": 42.0,
            "local_checkpoint": 42.0,
            "max_seq_no": 42.0
          },
          "store": {
            "size_in_bytes": 42.0,
            "reserved_in_bytes": 42.0,
            "total_data_set_size_in_bytes": 42.0
          },
          "translog": {
            "earliest_last_modified_age": 42.0,
            "operations": 42.0,
            "size": "string",
            "size_in_bytes": 42.0,
            "uncommitted_operations": 42.0,
            "uncommitted_size": "string",
            "uncommitted_size_in_bytes": 42.0
          },
          "warmer": {
            "current": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "bulk": {
            "total_operations": 42.0,
            "total_time": "string",
            "total_size_in_bytes": 42.0,
            "avg_time": "string",
            "avg_size_in_bytes": 42.0
          },
          "shards": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          },
          "shard_stats": {
            "total_count": 42.0
          },
          "additionalProperty1": {},
          "additionalProperty2": {}
        }
      ]
    },
    "total": {
      "completion": {
        "size_in_bytes": 42.0,
        "": 42.0,
        "fields": {
          "additionalProperty1": {
            "size_in_bytes": 42.0
          },
          "additionalProperty2": {
            "size_in_bytes": 42.0
          }
        }
      },
      "docs": {
        "count": 42.0,
        "deleted": 42.0
      },
      "fielddata": {
        "evictions": 42.0,
        "": 42.0,
        "memory_size_in_bytes": 42.0,
        "fields": {
          "additionalProperty1": {
            "memory_size_in_bytes": 42.0
          },
          "additionalProperty2": {
            "memory_size_in_bytes": 42.0
          }
        }
      },
      "flush": {
        "periodic": 42.0,
        "total": 42.0,
        "total_time": "string",
        "": 42.0
      },
      "get": {
        "current": 42.0,
        "exists_time": "string",
        "": 42.0,
        "exists_total": 42.0,
        "missing_time": "string",
        "missing_total": 42.0,
        "time": "string",
        "total": 42.0
      },
      "indexing": {
        "index_current": 42.0,
        "delete_current": 42.0,
        "delete_time": "string",
        "": 42.0,
        "delete_total": 42.0,
        "is_throttled": true,
        "noop_update_total": 42.0,
        "throttle_time": "string",
        "index_time": "string",
        "index_total": 42.0,
        "index_failed": 42.0,
        "types": {
          "*": {}
        },
        "write_load": 42.0
      },
      "additionalProperty1": {},
      "additionalProperty2": {},
      "merges": {
        "current": 42.0,
        "current_docs": 42.0,
        "current_size": "string",
        "current_size_in_bytes": 42.0,
        "total": 42.0,
        "total_auto_throttle": "string",
        "total_auto_throttle_in_bytes": 42.0,
        "total_docs": 42.0,
        "total_size": "string",
        "total_size_in_bytes": 42.0,
        "total_stopped_time": "string",
        "": 42.0,
        "total_throttled_time": "string",
        "total_time": "string"
      },
      "query_cache": {
        "cache_count": 42.0,
        "cache_size": 42.0,
        "evictions": 42.0,
        "hit_count": 42.0,
        "": 42.0,
        "memory_size_in_bytes": 42.0,
        "miss_count": 42.0,
        "total_count": 42.0
      },
      "recovery": {
        "current_as_source": 42.0,
        "current_as_target": 42.0,
        "throttle_time": "string",
        "": 42.0
      },
      "refresh": {
        "external_total": 42.0,
        "": 42.0,
        "listeners": 42.0,
        "total": 42.0,
        "total_time": "string"
      },
      "request_cache": {
        "evictions": 42.0,
        "hit_count": 42.0,
        "memory_size": "string",
        "memory_size_in_bytes": 42.0,
        "miss_count": 42.0
      },
      "search": {
        "fetch_current": 42.0,
        "fetch_time": "string",
        "": 42.0,
        "fetch_total": 42.0,
        "open_contexts": 42.0,
        "query_current": 42.0,
        "query_time": "string",
        "query_total": 42.0,
        "scroll_current": 42.0,
        "scroll_time": "string",
        "scroll_total": 42.0,
        "suggest_current": 42.0,
        "suggest_time": "string",
        "suggest_total": 42.0,
        "groups": {
          "*": {}
        }
      },
      "segments": {
        "count": 42.0,
        "": 42.0,
        "doc_values_memory_in_bytes": 42.0,
        "file_sizes": {
          "additionalProperty1": {
            "description": "string",
            "size_in_bytes": 42.0,
            "min_size_in_bytes": 42.0,
            "max_size_in_bytes": 42.0,
            "average_size_in_bytes": 42.0,
            "count": 42.0
          },
          "additionalProperty2": {
            "description": "string",
            "size_in_bytes": 42.0,
            "min_size_in_bytes": 42.0,
            "max_size_in_bytes": 42.0,
            "average_size_in_bytes": 42.0,
            "count": 42.0
          }
        },
        "fixed_bit_set_memory_in_bytes": 42.0,
        "index_writer_max_memory_in_bytes": 42.0,
        "index_writer_memory_in_bytes": 42.0,
        "max_unsafe_auto_id_timestamp": 42.0,
        "memory_in_bytes": 42.0,
        "norms_memory_in_bytes": 42.0,
        "points_memory_in_bytes": 42.0,
        "stored_fields_memory_in_bytes": 42.0,
        "terms_memory_in_bytes": 42.0,
        "term_vectors_memory_in_bytes": 42.0,
        "version_map_memory_in_bytes": 42.0
      },
      "store": {
        "": 42.0,
        "size_in_bytes": 42.0,
        "reserved_in_bytes": 42.0,
        "total_data_set_size_in_bytes": 42.0
      },
      "translog": {
        "earliest_last_modified_age": 42.0,
        "operations": 42.0,
        "size": "string",
        "size_in_bytes": 42.0,
        "uncommitted_operations": 42.0,
        "uncommitted_size": "string",
        "uncommitted_size_in_bytes": 42.0
      },
      "warmer": {
        "current": 42.0,
        "total": 42.0,
        "total_time": "string",
        "": 42.0
      },
      "bulk": {
        "total_operations": 42.0,
        "total_time": "string",
        "": 42.0,
        "total_size_in_bytes": 42.0,
        "avg_time": "string",
        "avg_size_in_bytes": 42.0
      },
      "shard_stats": {
        "total_count": 42.0
      }
    },
    "uuid": "string",
    "health": "green",
    "status": "open"
  },
  "additionalProperty2": {
    "primaries": {
      "completion": {
        "size_in_bytes": 42.0,
        "": 42.0,
        "fields": {
          "additionalProperty1": {
            "size_in_bytes": 42.0
          },
          "additionalProperty2": {
            "size_in_bytes": 42.0
          }
        }
      },
      "docs": {
        "count": 42.0,
        "deleted": 42.0
      },
      "fielddata": {
        "evictions": 42.0,
        "": 42.0,
        "memory_size_in_bytes": 42.0,
        "fields": {
          "additionalProperty1": {
            "memory_size_in_bytes": 42.0
          },
          "additionalProperty2": {
            "memory_size_in_bytes": 42.0
          }
        }
      },
      "flush": {
        "periodic": 42.0,
        "total": 42.0,
        "total_time": "string",
        "": 42.0
      },
      "get": {
        "current": 42.0,
        "exists_time": "string",
        "": 42.0,
        "exists_total": 42.0,
        "missing_time": "string",
        "missing_total": 42.0,
        "time": "string",
        "total": 42.0
      },
      "indexing": {
        "index_current": 42.0,
        "delete_current": 42.0,
        "delete_time": "string",
        "": 42.0,
        "delete_total": 42.0,
        "is_throttled": true,
        "noop_update_total": 42.0,
        "throttle_time": "string",
        "index_time": "string",
        "index_total": 42.0,
        "index_failed": 42.0,
        "types": {
          "*": {}
        },
        "write_load": 42.0
      },
      "additionalProperty1": {},
      "additionalProperty2": {},
      "merges": {
        "current": 42.0,
        "current_docs": 42.0,
        "current_size": "string",
        "current_size_in_bytes": 42.0,
        "total": 42.0,
        "total_auto_throttle": "string",
        "total_auto_throttle_in_bytes": 42.0,
        "total_docs": 42.0,
        "total_size": "string",
        "total_size_in_bytes": 42.0,
        "total_stopped_time": "string",
        "": 42.0,
        "total_throttled_time": "string",
        "total_time": "string"
      },
      "query_cache": {
        "cache_count": 42.0,
        "cache_size": 42.0,
        "evictions": 42.0,
        "hit_count": 42.0,
        "": 42.0,
        "memory_size_in_bytes": 42.0,
        "miss_count": 42.0,
        "total_count": 42.0
      },
      "recovery": {
        "current_as_source": 42.0,
        "current_as_target": 42.0,
        "throttle_time": "string",
        "": 42.0
      },
      "refresh": {
        "external_total": 42.0,
        "": 42.0,
        "listeners": 42.0,
        "total": 42.0,
        "total_time": "string"
      },
      "request_cache": {
        "evictions": 42.0,
        "hit_count": 42.0,
        "memory_size": "string",
        "memory_size_in_bytes": 42.0,
        "miss_count": 42.0
      },
      "search": {
        "fetch_current": 42.0,
        "fetch_time": "string",
        "": 42.0,
        "fetch_total": 42.0,
        "open_contexts": 42.0,
        "query_current": 42.0,
        "query_time": "string",
        "query_total": 42.0,
        "scroll_current": 42.0,
        "scroll_time": "string",
        "scroll_total": 42.0,
        "suggest_current": 42.0,
        "suggest_time": "string",
        "suggest_total": 42.0,
        "groups": {
          "*": {}
        }
      },
      "segments": {
        "count": 42.0,
        "": 42.0,
        "doc_values_memory_in_bytes": 42.0,
        "file_sizes": {
          "additionalProperty1": {
            "description": "string",
            "size_in_bytes": 42.0,
            "min_size_in_bytes": 42.0,
            "max_size_in_bytes": 42.0,
            "average_size_in_bytes": 42.0,
            "count": 42.0
          },
          "additionalProperty2": {
            "description": "string",
            "size_in_bytes": 42.0,
            "min_size_in_bytes": 42.0,
            "max_size_in_bytes": 42.0,
            "average_size_in_bytes": 42.0,
            "count": 42.0
          }
        },
        "fixed_bit_set_memory_in_bytes": 42.0,
        "index_writer_max_memory_in_bytes": 42.0,
        "index_writer_memory_in_bytes": 42.0,
        "max_unsafe_auto_id_timestamp": 42.0,
        "memory_in_bytes": 42.0,
        "norms_memory_in_bytes": 42.0,
        "points_memory_in_bytes": 42.0,
        "stored_fields_memory_in_bytes": 42.0,
        "terms_memory_in_bytes": 42.0,
        "term_vectors_memory_in_bytes": 42.0,
        "version_map_memory_in_bytes": 42.0
      },
      "store": {
        "": 42.0,
        "size_in_bytes": 42.0,
        "reserved_in_bytes": 42.0,
        "total_data_set_size_in_bytes": 42.0
      },
      "translog": {
        "earliest_last_modified_age": 42.0,
        "operations": 42.0,
        "size": "string",
        "size_in_bytes": 42.0,
        "uncommitted_operations": 42.0,
        "uncommitted_size": "string",
        "uncommitted_size_in_bytes": 42.0
      },
      "warmer": {
        "current": 42.0,
        "total": 42.0,
        "total_time": "string",
        "": 42.0
      },
      "bulk": {
        "total_operations": 42.0,
        "total_time": "string",
        "": 42.0,
        "total_size_in_bytes": 42.0,
        "avg_time": "string",
        "avg_size_in_bytes": 42.0
      },
      "shard_stats": {
        "total_count": 42.0
      }
    },
    "shards": {
      "additionalProperty1": [
        {
          "commit": {
            "generation": 42.0,
            "id": "string",
            "num_docs": 42.0,
            "user_data": {}
          },
          "completion": {
            "size_in_bytes": 42.0,
            "fields": {}
          },
          "docs": {
            "count": 42.0,
            "deleted": 42.0
          },
          "fielddata": {
            "evictions": 42.0,
            "memory_size_in_bytes": 42.0,
            "fields": {}
          },
          "flush": {
            "periodic": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "get": {
            "current": 42.0,
            "exists_time": "string",
            "exists_total": 42.0,
            "missing_time": "string",
            "missing_total": 42.0,
            "time": "string",
            "total": 42.0
          },
          "indexing": {
            "index_current": 42.0,
            "delete_current": 42.0,
            "delete_time": "string",
            "delete_total": 42.0,
            "is_throttled": true,
            "noop_update_total": 42.0,
            "throttle_time": "string",
            "index_time": "string",
            "index_total": 42.0,
            "index_failed": 42.0,
            "types": {},
            "write_load": 42.0
          },
          "mappings": {
            "total_count": 42.0,
            "total_estimated_overhead_in_bytes": 42.0
          },
          "merges": {
            "current": 42.0,
            "current_docs": 42.0,
            "current_size": "string",
            "current_size_in_bytes": 42.0,
            "total": 42.0,
            "total_auto_throttle": "string",
            "total_auto_throttle_in_bytes": 42.0,
            "total_docs": 42.0,
            "total_size": "string",
            "total_size_in_bytes": 42.0,
            "total_stopped_time": "string",
            "total_throttled_time": "string",
            "total_time": "string"
          },
          "shard_path": {
            "data_path": "string",
            "is_custom_data_path": true,
            "state_path": "string"
          },
          "query_cache": {
            "cache_count": 42.0,
            "cache_size": 42.0,
            "evictions": 42.0,
            "hit_count": 42.0,
            "memory_size_in_bytes": 42.0,
            "miss_count": 42.0,
            "total_count": 42.0
          },
          "recovery": {
            "current_as_source": 42.0,
            "current_as_target": 42.0,
            "throttle_time": "string"
          },
          "refresh": {
            "external_total": 42.0,
            "listeners": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "request_cache": {
            "evictions": 42.0,
            "hit_count": 42.0,
            "memory_size": "string",
            "memory_size_in_bytes": 42.0,
            "miss_count": 42.0
          },
          "retention_leases": {
            "primary_term": 42.0,
            "version": 42.0,
            "leases": [
              {}
            ]
          },
          "routing": {
            "node": "string",
            "primary": true,
            "state": "UNASSIGNED"
          },
          "search": {
            "fetch_current": 42.0,
            "fetch_time": "string",
            "fetch_total": 42.0,
            "open_contexts": 42.0,
            "query_current": 42.0,
            "query_time": "string",
            "query_total": 42.0,
            "scroll_current": 42.0,
            "scroll_time": "string",
            "scroll_total": 42.0,
            "suggest_current": 42.0,
            "suggest_time": "string",
            "suggest_total": 42.0,
            "groups": {}
          },
          "segments": {
            "count": 42.0,
            "doc_values_memory_in_bytes": 42.0,
            "file_sizes": {},
            "fixed_bit_set_memory_in_bytes": 42.0,
            "index_writer_max_memory_in_bytes": 42.0,
            "index_writer_memory_in_bytes": 42.0,
            "max_unsafe_auto_id_timestamp": 42.0,
            "memory_in_bytes": 42.0,
            "norms_memory_in_bytes": 42.0,
            "points_memory_in_bytes": 42.0,
            "stored_fields_memory_in_bytes": 42.0,
            "terms_memory_in_bytes": 42.0,
            "term_vectors_memory_in_bytes": 42.0,
            "version_map_memory_in_bytes": 42.0
          },
          "seq_no": {
            "global_checkpoint": 42.0,
            "local_checkpoint": 42.0,
            "max_seq_no": 42.0
          },
          "store": {
            "size_in_bytes": 42.0,
            "reserved_in_bytes": 42.0,
            "total_data_set_size_in_bytes": 42.0
          },
          "translog": {
            "earliest_last_modified_age": 42.0,
            "operations": 42.0,
            "size": "string",
            "size_in_bytes": 42.0,
            "uncommitted_operations": 42.0,
            "uncommitted_size": "string",
            "uncommitted_size_in_bytes": 42.0
          },
          "warmer": {
            "current": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "bulk": {
            "total_operations": 42.0,
            "total_time": "string",
            "total_size_in_bytes": 42.0,
            "avg_time": "string",
            "avg_size_in_bytes": 42.0
          },
          "shards": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          },
          "shard_stats": {
            "total_count": 42.0
          },
          "additionalProperty1": {},
          "additionalProperty2": {}
        }
      ],
      "additionalProperty2": [
        {
          "commit": {
            "generation": 42.0,
            "id": "string",
            "num_docs": 42.0,
            "user_data": {}
          },
          "completion": {
            "size_in_bytes": 42.0,
            "fields": {}
          },
          "docs": {
            "count": 42.0,
            "deleted": 42.0
          },
          "fielddata": {
            "evictions": 42.0,
            "memory_size_in_bytes": 42.0,
            "fields": {}
          },
          "flush": {
            "periodic": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "get": {
            "current": 42.0,
            "exists_time": "string",
            "exists_total": 42.0,
            "missing_time": "string",
            "missing_total": 42.0,
            "time": "string",
            "total": 42.0
          },
          "indexing": {
            "index_current": 42.0,
            "delete_current": 42.0,
            "delete_time": "string",
            "delete_total": 42.0,
            "is_throttled": true,
            "noop_update_total": 42.0,
            "throttle_time": "string",
            "index_time": "string",
            "index_total": 42.0,
            "index_failed": 42.0,
            "types": {},
            "write_load": 42.0
          },
          "mappings": {
            "total_count": 42.0,
            "total_estimated_overhead_in_bytes": 42.0
          },
          "merges": {
            "current": 42.0,
            "current_docs": 42.0,
            "current_size": "string",
            "current_size_in_bytes": 42.0,
            "total": 42.0,
            "total_auto_throttle": "string",
            "total_auto_throttle_in_bytes": 42.0,
            "total_docs": 42.0,
            "total_size": "string",
            "total_size_in_bytes": 42.0,
            "total_stopped_time": "string",
            "total_throttled_time": "string",
            "total_time": "string"
          },
          "shard_path": {
            "data_path": "string",
            "is_custom_data_path": true,
            "state_path": "string"
          },
          "query_cache": {
            "cache_count": 42.0,
            "cache_size": 42.0,
            "evictions": 42.0,
            "hit_count": 42.0,
            "memory_size_in_bytes": 42.0,
            "miss_count": 42.0,
            "total_count": 42.0
          },
          "recovery": {
            "current_as_source": 42.0,
            "current_as_target": 42.0,
            "throttle_time": "string"
          },
          "refresh": {
            "external_total": 42.0,
            "listeners": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "request_cache": {
            "evictions": 42.0,
            "hit_count": 42.0,
            "memory_size": "string",
            "memory_size_in_bytes": 42.0,
            "miss_count": 42.0
          },
          "retention_leases": {
            "primary_term": 42.0,
            "version": 42.0,
            "leases": [
              {}
            ]
          },
          "routing": {
            "node": "string",
            "primary": true,
            "state": "UNASSIGNED"
          },
          "search": {
            "fetch_current": 42.0,
            "fetch_time": "string",
            "fetch_total": 42.0,
            "open_contexts": 42.0,
            "query_current": 42.0,
            "query_time": "string",
            "query_total": 42.0,
            "scroll_current": 42.0,
            "scroll_time": "string",
            "scroll_total": 42.0,
            "suggest_current": 42.0,
            "suggest_time": "string",
            "suggest_total": 42.0,
            "groups": {}
          },
          "segments": {
            "count": 42.0,
            "doc_values_memory_in_bytes": 42.0,
            "file_sizes": {},
            "fixed_bit_set_memory_in_bytes": 42.0,
            "index_writer_max_memory_in_bytes": 42.0,
            "index_writer_memory_in_bytes": 42.0,
            "max_unsafe_auto_id_timestamp": 42.0,
            "memory_in_bytes": 42.0,
            "norms_memory_in_bytes": 42.0,
            "points_memory_in_bytes": 42.0,
            "stored_fields_memory_in_bytes": 42.0,
            "terms_memory_in_bytes": 42.0,
            "term_vectors_memory_in_bytes": 42.0,
            "version_map_memory_in_bytes": 42.0
          },
          "seq_no": {
            "global_checkpoint": 42.0,
            "local_checkpoint": 42.0,
            "max_seq_no": 42.0
          },
          "store": {
            "size_in_bytes": 42.0,
            "reserved_in_bytes": 42.0,
            "total_data_set_size_in_bytes": 42.0
          },
          "translog": {
            "earliest_last_modified_age": 42.0,
            "operations": 42.0,
            "size": "string",
            "size_in_bytes": 42.0,
            "uncommitted_operations": 42.0,
            "uncommitted_size": "string",
            "uncommitted_size_in_bytes": 42.0
          },
          "warmer": {
            "current": 42.0,
            "total": 42.0,
            "total_time": "string"
          },
          "bulk": {
            "total_operations": 42.0,
            "total_time": "string",
            "total_size_in_bytes": 42.0,
            "avg_time": "string",
            "avg_size_in_bytes": 42.0
          },
          "shards": {
            "additionalProperty1": {},
            "additionalProperty2": {}
          },
          "shard_stats": {
            "total_count": 42.0
          },
          "additionalProperty1": {},
          "additionalProperty2": {}
        }
      ]
    },
    "total": {
      "completion": {
        "size_in_bytes": 42.0,
        "": 42.0,
        "fields": {
          "additionalProperty1": {
            "size_in_bytes": 42.0
          },
          "additionalProperty2": {
            "size_in_bytes": 42.0
          }
        }
      },
      "docs": {
        "count": 42.0,
        "deleted": 42.0
      },
      "fielddata": {
        "evictions": 42.0,
        "": 42.0,
        "memory_size_in_bytes": 42.0,
        "fields": {
          "additionalProperty1": {
            "memory_size_in_bytes": 42.0
          },
          "additionalProperty2": {
            "memory_size_in_bytes": 42.0
          }
        }
      },
      "flush": {
        "periodic": 42.0,
        "total": 42.0,
        "total_time": "string",
        "": 42.0
      },
      "get": {
        "current": 42.0,
        "exists_time": "string",
        "": 42.0,
        "exists_total": 42.0,
        "missing_time": "string",
        "missing_total": 42.0,
        "time": "string",
        "total": 42.0
      },
      "indexing": {
        "index_current": 42.0,
        "delete_current": 42.0,
        "delete_time": "string",
        "": 42.0,
        "delete_total": 42.0,
        "is_throttled": true,
        "noop_update_total": 42.0,
        "throttle_time": "string",
        "index_time": "string",
        "index_total": 42.0,
        "index_failed": 42.0,
        "types": {
          "*": {}
        },
        "write_load": 42.0
      },
      "additionalProperty1": {},
      "additionalProperty2": {},
      "merges": {
        "current": 42.0,
        "current_docs": 42.0,
        "current_size": "string",
        "current_size_in_bytes": 42.0,
        "total": 42.0,
        "total_auto_throttle": "string",
        "total_auto_throttle_in_bytes": 42.0,
        "total_docs": 42.0,
        "total_size": "string",
        "total_size_in_bytes": 42.0,
        "total_stopped_time": "string",
        "": 42.0,
        "total_throttled_time": "string",
        "total_time": "string"
      },
      "query_cache": {
        "cache_count": 42.0,
        "cache_size": 42.0,
        "evictions": 42.0,
        "hit_count": 42.0,
        "": 42.0,
        "memory_size_in_bytes": 42.0,
        "miss_count": 42.0,
        "total_count": 42.0
      },
      "recovery": {
        "current_as_source": 42.0,
        "current_as_target": 42.0,
        "throttle_time": "string",
        "": 42.0
      },
      "refresh": {
        "external_total": 42.0,
        "": 42.0,
        "listeners": 42.0,
        "total": 42.0,
        "total_time": "string"
      },
      "request_cache": {
        "evictions": 42.0,
        "hit_count": 42.0,
        "memory_size": "string",
        "memory_size_in_bytes": 42.0,
        "miss_count": 42.0
      },
      "search": {
        "fetch_current": 42.0,
        "fetch_time": "string",
        "": 42.0,
        "fetch_total": 42.0,
        "open_contexts": 42.0,
        "query_current": 42.0,
        "query_time": "string",
        "query_total": 42.0,
        "scroll_current": 42.0,
        "scroll_time": "string",
        "scroll_total": 42.0,
        "suggest_current": 42.0,
        "suggest_time": "string",
        "suggest_total": 42.0,
        "groups": {
          "*": {}
        }
      },
      "segments": {
        "count": 42.0,
        "": 42.0,
        "doc_values_memory_in_bytes": 42.0,
        "file_sizes": {
          "additionalProperty1": {
            "description": "string",
            "size_in_bytes": 42.0,
            "min_size_in_bytes": 42.0,
            "max_size_in_bytes": 42.0,
            "average_size_in_bytes": 42.0,
            "count": 42.0
          },
          "additionalProperty2": {
            "description": "string",
            "size_in_bytes": 42.0,
            "min_size_in_bytes": 42.0,
            "max_size_in_bytes": 42.0,
            "average_size_in_bytes": 42.0,
            "count": 42.0
          }
        },
        "fixed_bit_set_memory_in_bytes": 42.0,
        "index_writer_max_memory_in_bytes": 42.0,
        "index_writer_memory_in_bytes": 42.0,
        "max_unsafe_auto_id_timestamp": 42.0,
        "memory_in_bytes": 42.0,
        "norms_memory_in_bytes": 42.0,
        "points_memory_in_bytes": 42.0,
        "stored_fields_memory_in_bytes": 42.0,
        "terms_memory_in_bytes": 42.0,
        "term_vectors_memory_in_bytes": 42.0,
        "version_map_memory_in_bytes": 42.0
      },
      "store": {
        "": 42.0,
        "size_in_bytes": 42.0,
        "reserved_in_bytes": 42.0,
        "total_data_set_size_in_bytes": 42.0
      },
      "translog": {
        "earliest_last_modified_age": 42.0,
        "operations": 42.0,
        "size": "string",
        "size_in_bytes": 42.0,
        "uncommitted_operations": 42.0,
        "uncommitted_size": "string",
        "uncommitted_size_in_bytes": 42.0
      },
      "warmer": {
        "current": 42.0,
        "total": 42.0,
        "total_time": "string",
        "": 42.0
      },
      "bulk": {
        "total_operations": 42.0,
        "total_time": "string",
        "": 42.0,
        "total_size_in_bytes": 42.0,
        "avg_time": "string",
        "avg_size_in_bytes": 42.0
      },
      "shard_stats": {
        "total_count": 42.0
      }
    },
    "uuid": "string",
    "health": "green",
    "status": "open"
  }
}




















































































































































































































































































































































Delete expired ML data Added in 5.4.0

DELETE /_ml/_delete_expired_data/{job_id}

Delete all job results, model snapshots and forecast data that have exceeded their retention days period. Machine learning state documents that are not associated with any job are also deleted. You can limit the request to a single or set of anomaly detection jobs by using a job identifier, a group name, a comma-separated list of jobs, or a wildcard expression. You can delete expired data for all anomaly detection jobs by using _all, by specifying * as the <job_id>, or by omitting the <job_id>.

Path parameters

  • job_id string Required

    Identifier for an anomaly detection job. It can be a job identifier, a group name, or a wildcard expression.

Query parameters

  • The desired requests per second for the deletion processes. The default behavior is no throttling.

  • timeout string

    How long can the underlying delete processes run until they are canceled.

application/json

Body

  • The desired requests per second for the deletion processes. The default behavior is no throttling.

  • timeout string

    A duration. Units can be nanos, micros, ms (milliseconds), s (seconds), m (minutes), h (hours) and d (days). Also accepts "0" without a unit and "-1" to indicate an unspecified value.

Responses

  • 200 application/json
    Hide response attribute Show response attribute object
DELETE /_ml/_delete_expired_data/{job_id}
curl \
 --request DELETE http://api.example.com/_ml/_delete_expired_data/{job_id} \
 --header "Content-Type: application/json" \
 --data '{"requests_per_second":42.0,"timeout":"string"}'
Request examples
{
  "requests_per_second": 42.0,
  "timeout": "string"
}
Response examples (200)
A successful response when deleting expired and unused anomaly detection data.
{
  "deleted": true
}










































































































































































































































































































































































Create a trained model vocabulary Added in 8.0.0

PUT /_ml/trained_models/{model_id}/vocabulary

This API is supported only for natural language processing (NLP) models. The vocabulary is stored in the index as described in inference_config.*.vocabulary of the trained model definition.

Path parameters

  • model_id string Required

    The unique identifier of the trained model.

application/json

Body Required

  • vocabulary array[string] Required

    The model vocabulary, which must not be empty.

  • merges array[string]

    The optional model merges if required by the tokenizer.

  • scores array[number]

    The optional vocabulary value scores if required by the tokenizer.

Responses

  • 200 application/json
    Hide response attribute Show response attribute object
    • acknowledged boolean Required

      For a successful response, this value is always true. On failure, an exception is returned instead.

PUT /_ml/trained_models/{model_id}/vocabulary
curl \
 --request PUT http://api.example.com/_ml/trained_models/{model_id}/vocabulary \
 --header "Content-Type: application/json" \
 --data '{"vocabulary":["string"],"merges":["string"],"scores":[42.0]}'
Request examples
{
  "vocabulary": [
    "string"
  ],
  "merges": [
    "string"
  ],
  "scores": [
    42.0
  ]
}
Response examples (200)
{
  "acknowledged": true
}












Migration