http://api.example.comElasticsearch provides REST APIs that are used by the UI components and can be called directly to configure and access Elasticsearch features.
This documentation is derived from the main branch of the elasticsearch-specification repository. It is provided under license Attribution-NonCommercial-NoDerivatives 4.0 International.
This documentation contains work-in-progress information for future Elastic Stack releases.
Last update on Sep 16, 2025.
This API is provided under license Apache 2.0.
The API accepts 3 different authentication methods:
Elasticsearch APIs support key-based authentication. You must create an API key and use the encoded value in the request header. For example:
curl -X GET "${ES_URL}/_cat/indices?v=true" \
-H "Authorization: ApiKey ${API_KEY}"
To get API keys, use the /_security/api_key APIs.
Elasticsearch APIs support the use of bearer tokens in the Authorization HTTP header to authenticate with the API.
For examples, refer to Token-based authentication services
All methods and paths for this operation:
GET _application/analytics/my*
resp = client.search_application.get_behavioral_analytics(
name="my*",
)const response = await client.searchApplication.getBehavioralAnalytics({
name: "my*",
});response = client.search_application.get_behavioral_analytics(
name: "my*"
)$resp = $client->searchApplication()->getBehavioralAnalytics([
"name" => "my*",
]);curl -X GET -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_application/analytics/my*"{
"my_analytics_collection": {
"event_data_stream": {
"name": "behavioral_analytics-events-my_analytics_collection"
}
},
"my_analytics_collection2": {
"event_data_stream": {
"name": "behavioral_analytics-events-my_analytics_collection2"
}
}
}PUT _application/analytics/my_analytics_collection
resp = client.search_application.put_behavioral_analytics(
name="my_analytics_collection",
)const response = await client.searchApplication.putBehavioralAnalytics({
name: "my_analytics_collection",
});response = client.search_application.put_behavioral_analytics(
name: "my_analytics_collection"
)$resp = $client->searchApplication()->putBehavioralAnalytics([
"name" => "my_analytics_collection",
]);curl -X PUT -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_application/analytics/my_analytics_collection"DELETE _application/analytics/my_analytics_collection/
resp = client.search_application.delete_behavioral_analytics(
name="my_analytics_collection",
)const response = await client.searchApplication.deleteBehavioralAnalytics({
name: "my_analytics_collection",
});response = client.search_application.delete_behavioral_analytics(
name: "my_analytics_collection"
)$resp = $client->searchApplication()->deleteBehavioralAnalytics([
"name" => "my_analytics_collection",
]);curl -X DELETE -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_application/analytics/my_analytics_collection/"The name of the behavioral analytics collection.
The analytics event type.
Values are page_view, search, or search_click.
POST _application/analytics/my_analytics_collection/event/search_click
{
"session": {
"id": "1797ca95-91c9-4e2e-b1bd-9c38e6f386a9"
},
"user": {
"id": "5f26f01a-bbee-4202-9298-81261067abbd"
},
"search":{
"query": "search term",
"results": {
"items": [
{
"document": {
"id": "123",
"index": "products"
}
}
],
"total_results": 10
},
"sort": {
"name": "relevance"
},
"search_application": "website"
},
"document":{
"id": "123",
"index": "products"
}
}resp = client.search_application.post_behavioral_analytics_event(
collection_name="my_analytics_collection",
event_type="search_click",
payload={
"session": {
"id": "1797ca95-91c9-4e2e-b1bd-9c38e6f386a9"
},
"user": {
"id": "5f26f01a-bbee-4202-9298-81261067abbd"
},
"search": {
"query": "search term",
"results": {
"items": [
{
"document": {
"id": "123",
"index": "products"
}
}
],
"total_results": 10
},
"sort": {
"name": "relevance"
},
"search_application": "website"
},
"document": {
"id": "123",
"index": "products"
}
},
)const response = await client.searchApplication.postBehavioralAnalyticsEvent({
collection_name: "my_analytics_collection",
event_type: "search_click",
payload: {
session: {
id: "1797ca95-91c9-4e2e-b1bd-9c38e6f386a9",
},
user: {
id: "5f26f01a-bbee-4202-9298-81261067abbd",
},
search: {
query: "search term",
results: {
items: [
{
document: {
id: "123",
index: "products",
},
},
],
total_results: 10,
},
sort: {
name: "relevance",
},
search_application: "website",
},
document: {
id: "123",
index: "products",
},
},
});response = client.search_application.post_behavioral_analytics_event(
collection_name: "my_analytics_collection",
event_type: "search_click",
body: {
"session": {
"id": "1797ca95-91c9-4e2e-b1bd-9c38e6f386a9"
},
"user": {
"id": "5f26f01a-bbee-4202-9298-81261067abbd"
},
"search": {
"query": "search term",
"results": {
"items": [
{
"document": {
"id": "123",
"index": "products"
}
}
],
"total_results": 10
},
"sort": {
"name": "relevance"
},
"search_application": "website"
},
"document": {
"id": "123",
"index": "products"
}
}
)$resp = $client->searchApplication()->postBehavioralAnalyticsEvent([
"collection_name" => "my_analytics_collection",
"event_type" => "search_click",
"body" => [
"session" => [
"id" => "1797ca95-91c9-4e2e-b1bd-9c38e6f386a9",
],
"user" => [
"id" => "5f26f01a-bbee-4202-9298-81261067abbd",
],
"search" => [
"query" => "search term",
"results" => [
"items" => array(
[
"document" => [
"id" => "123",
"index" => "products",
],
],
),
"total_results" => 10,
],
"sort" => [
"name" => "relevance",
],
"search_application" => "website",
],
"document" => [
"id" => "123",
"index" => "products",
],
],
]);curl -X POST -H "Authorization: ApiKey $ELASTIC_API_KEY" -H "Content-Type: application/json" -d '{"session":{"id":"1797ca95-91c9-4e2e-b1bd-9c38e6f386a9"},"user":{"id":"5f26f01a-bbee-4202-9298-81261067abbd"},"search":{"query":"search term","results":{"items":[{"document":{"id":"123","index":"products"}}],"total_results":10},"sort":{"name":"relevance"},"search_application":"website"},"document":{"id":"123","index":"products"}}' "$ELASTICSEARCH_URL/_application/analytics/my_analytics_collection/event/search_click"{
"session": {
"id": "1797ca95-91c9-4e2e-b1bd-9c38e6f386a9"
},
"user": {
"id": "5f26f01a-bbee-4202-9298-81261067abbd"
},
"search":{
"query": "search term",
"results": {
"items": [
{
"document": {
"id": "123",
"index": "products"
}
}
],
"total_results": 10
},
"sort": {
"name": "relevance"
},
"search_application": "website"
},
"document":{
"id": "123",
"index": "products"
}
}The compact and aligned text (CAT) APIs aim are intended only for human consumption using the Kibana console or command line. They are not intended for use by applications. For application consumption, it's recommend to use a corresponding JSON API.
All the cat commands accept a query string parameter help to see all the headers and info they provide, and the /_cat command alone lists all the available commands.
All methods and paths for this operation:
Get the cluster's index aliases, including filter and routing information. This API does not return data stream aliases.
IMPORTANT: CAT APIs are only intended for human consumption using the command line or the Kibana console. They are not intended for use by applications. For application consumption, use the aliases API.
view_index_metadataA comma-separated list of aliases to retrieve. Supports wildcards (*). To retrieve all aliases, omit this parameter or use * or _all.
A comma-separated list of columns names to display. It supports simple wildcards.
Supported values include:
alias (or a): The name of the alias.index (or i, idx): The name of the index the alias points to.filter (or f, fi): The filter applied to the alias.routing.index (or ri, routingIndex): Index routing value for the alias.routing.search (or rs, routingSearch): Search routing value for the alias.is_write_index (or w, isWriteIndex): Indicates if the index is the write index for the alias.Values are alias, a, index, i, idx, filter, f, fi, routing.index, ri, routingIndex, routing.search, rs, routingSearch, is_write_index, w, or isWriteIndex.
List of columns that determine how the table should be sorted.
Sorting defaults to ascending and can be changed by setting :asc
or :desc as a suffix to the column name.
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.
Supported values include:
all: Match any data stream or index, including hidden ones.open: Match open, non-hidden indices. Also matches any non-hidden data stream.closed: Match closed, non-hidden indices. Also matches any non-hidden data stream. Data streams cannot be closed.hidden: Match hidden data streams and hidden indices. Must be combined with open, closed, or both.none: Wildcard expressions are not accepted.Values are all, open, closed, hidden, or none.
The period to wait for a connection to the master node.
If the master node is not available before the timeout expires, the request fails and returns an error.
To indicated that the request should never timeout, you can set it to -1.
Values are -1 or 0.
GET _cat/aliases?format=json&v=true
resp = client.cat.aliases(
format="json",
v=True,
)const response = await client.cat.aliases({
format: "json",
v: "true",
});response = client.cat.aliases(
format: "json",
v: "true"
)$resp = $client->cat()->aliases([
"format" => "json",
"v" => "true",
]);curl -X GET -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_cat/aliases?format=json&v=true"[
{
"alias": "alias1",
"index": "test1",
"filter": "-",
"routing.index": "-",
"routing.search": "-",
"is_write_index": "true"
},
{
"alias": "alias1",
"index": "test1",
"filter": "*",
"routing.index": "-",
"routing.search": "-",
"is_write_index": "true"
},
{
"alias": "alias3",
"index": "test1",
"filter": "-",
"routing.index": "1",
"routing.search": "1",
"is_write_index": "true"
},
{
"alias": "alias4",
"index": "test1",
"filter": "-",
"routing.index": "2",
"routing.search": "1,2",
"is_write_index": "true"
}
]All methods and paths for this operation:
Get a snapshot of the number of shards allocated to each data node and their disk space.
IMPORTANT: CAT APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications.
monitorA comma-separated list of node identifiers or names used to limit the returned information.
The unit used to display byte values.
Values are b, kb, mb, gb, tb, or pb.
A comma-separated list of columns names to display. It supports simple wildcards.
Supported values include:
shards (or s): The number of shards on the node.shards.undesired: The number of shards scheduled to be moved elsewhere in the cluster.write_load.forecast (or wlf, writeLoadForecast): The sum of index write load forecasts.disk.indices.forecast (or dif, diskIndicesForecast): The sum of shard size forecasts.disk.indices (or di, diskIndices): The disk space used by Elasticsearch indices.disk.used (or du, diskUsed): The total disk space used on the node.disk.avail (or da, diskAvail): The available disk space on the node.disk.total (or dt, diskTotal): The total disk capacity of all volumes on the node.disk.percent (or dp, diskPercent): The percentage of disk space used on the node.host (or h): IThe host of the node.ip: The IP address of the node.node (or n): The name of the node.node.role (or r, role, nodeRole): The roles assigned to the node.Values are shards, s, shards.undesired, write_load.forecast, wlf, writeLoadForecast, disk.indices.forecast, dif, diskIndicesForecast, disk.indices, di, diskIndices, disk.used, du, diskUsed, disk.avail, da, diskAvail, disk.total, dt, diskTotal, disk.percent, dp, diskPercent, host, h, ip, node, n, node.role, r, role, or nodeRole.
List of columns that determine how the table should be sorted.
Sorting defaults to ascending and can be changed by setting :asc
or :desc as a suffix to the column name.
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.
Values are -1 or 0.
GET /_cat/allocation?v=true&format=json
resp = client.cat.allocation(
v=True,
format="json",
)const response = await client.cat.allocation({
v: "true",
format: "json",
});response = client.cat.allocation(
v: "true",
format: "json"
)$resp = $client->cat()->allocation([
"v" => "true",
"format" => "json",
]);curl -X GET -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_cat/allocation?v=true&format=json"[
{
"shards": "1",
"shards.undesired": "0",
"write_load.forecast": "0.0",
"disk.indices.forecast": "260b",
"disk.indices": "260b",
"disk.used": "47.3gb",
"disk.avail": "43.4gb",
"disk.total": "100.7gb",
"disk.percent": "46",
"host": "127.0.0.1",
"ip": "127.0.0.1",
"node": "CSUXak2",
"node.role": "himrst"
}
]All methods and paths for this operation:
Get information about component templates in a cluster. Component templates are building blocks for constructing index templates that specify index mappings, settings, and aliases.
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 get component template API.
monitorThe name of the component template. It accepts wildcard expressions. If it is omitted, all component templates are returned.
A comma-separated list of columns names to display. It supports simple wildcards.
Supported values include:
name (or n): The name of the component template.version (or v): The version number of the component template.alias_count (or a): The number of aliases in the component template.mapping_count (or m): The number of mappings in the component template.settings_count (or s): The number of settings in the component template.metadata_count (or me): The number of metadata entries in the component template.included_in (or i): The index templates that include this component template.Values are name, n, version, v, alias_count, a, mapping_count, m, settings_count, s, metadata_count, me, included_in, or i.
List of columns that determine how the table should be sorted.
Sorting defaults to ascending and can be changed by setting :asc
or :desc as a suffix to the column name.
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.
The period to wait for a connection to the master node.
Values are -1 or 0.
GET _cat/component_templates/my-template-*?v=true&s=name&format=json
resp = client.cat.component_templates(
name="my-template-*",
v=True,
s="name",
format="json",
)const response = await client.cat.componentTemplates({
name: "my-template-*",
v: "true",
s: "name",
format: "json",
});response = client.cat.component_templates(
name: "my-template-*",
v: "true",
s: "name",
format: "json"
)$resp = $client->cat()->componentTemplates([
"name" => "my-template-*",
"v" => "true",
"s" => "name",
"format" => "json",
]);curl -X GET -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_cat/component_templates/my-template-*?v=true&s=name&format=json"[
{
"name": "my-template-1",
"version": "null",
"alias_count": "0",
"mapping_count": "0",
"settings_count": "1",
"metadata_count": "0",
"included_in": "[my-index-template]"
},
{
"name": "my-template-2",
"version": null,
"alias_count": "0",
"mapping_count": "3",
"settings_count": "0",
"metadata_count": "0",
"included_in": "[my-index-template]"
}
]All methods and paths for this operation:
Get quick access to a document count for a data stream, an index, or an entire cluster. The document count only includes live documents, not deleted documents which have not yet been removed by the merge process.
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 count API.
readA comma-separated list of data streams, indices, and aliases used to limit the request.
It supports wildcards (*).
To target all data streams and indices, omit this parameter or use * or _all.
A comma-separated list of columns names to display. It supports simple wildcards.
Supported values include:
epoch (or t, time): The Unix epoch time in seconds since 1970-01-01 00:00:00.timestamp (or ts, hms, hhmmss): The current time in HH:MM:SS format.count (or dc, docs.count, docsCount): The document count in the cluster or index.Values are epoch, t, time, timestamp, ts, hms, hhmmss, count, dc, docs.count, or docsCount.
List of columns that determine how the table should be sorted.
Sorting defaults to ascending and can be changed by setting :asc
or :desc as a suffix to the column name.
GET /_cat/count/my-index-000001?v=true&format=json
resp = client.cat.count(
index="my-index-000001",
v=True,
format="json",
)const response = await client.cat.count({
index: "my-index-000001",
v: "true",
format: "json",
});response = client.cat.count(
index: "my-index-000001",
v: "true",
format: "json"
)$resp = $client->cat()->count([
"index" => "my-index-000001",
"v" => "true",
"format" => "json",
]);curl -X GET -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_cat/count/my-index-000001?v=true&format=json"[
{
"epoch": "1475868259",
"timestamp": "15:24:20",
"count": "120"
}
][
{
"epoch": "1475868259",
"timestamp": "15:24:20",
"count": "121"
}
]All methods and paths for this operation:
Get the amount of heap memory currently used by the field data cache on every data node in the cluster.
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 nodes stats API.
monitorComma-separated list of fields used to limit returned information. To retrieve all fields, omit this parameter.
The unit used to display byte values.
Values are b, kb, mb, gb, tb, or pb.
Comma-separated list of fields used to limit returned information.
A comma-separated list of columns names to display. It supports simple wildcards.
Supported values include:
id: The node ID.host (or h): The host name of the node.ip: The IP address of the node.node (or n): The node name.field (or f): The field name.size (or s): The field data usage.Values are id, host, h, ip, node, n, field, f, size, or s.
List of columns that determine how the table should be sorted.
Sorting defaults to ascending and can be changed by setting :asc
or :desc as a suffix to the column name.
GET /_cat/fielddata?v=true&fields=body&format=json
resp = client.cat.fielddata(
v=True,
fields="body",
format="json",
)const response = await client.cat.fielddata({
v: "true",
fields: "body",
format: "json",
});response = client.cat.fielddata(
v: "true",
fields: "body",
format: "json"
)$resp = $client->cat()->fielddata([
"v" => "true",
"fields" => "body",
"format" => "json",
]);curl -X GET -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_cat/fielddata?v=true&fields=body&format=json"[
{
"id": "Nqk-6inXQq-OxUfOUI8jNQ",
"host": "127.0.0.1",
"ip": "127.0.0.1",
"node": "Nqk-6in",
"field": "body",
"size": "544b"
}
][
{
"id": "Nqk-6inXQq-OxUfOUI8jNQ",
"host": "1127.0.0.1",
"ip": "127.0.0.1",
"node": "Nqk-6in",
"field": "body",
"size": "544b"
},
{
"id": "Nqk-6inXQq-OxUfOUI8jNQ",
"host": "127.0.0.1",
"ip": "127.0.0.1",
"node": "Nqk-6in",
"field": "soul",
"size": "480b"
}
]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 cluster health API.
This API is often used to check malfunctioning clusters.
To help you track cluster health alongside log files and alerting systems, the API returns timestamps in two formats:
HH:MM:SS, which is human-readable but includes no date information;
Unix epoch time, which is machine-sortable and includes date information.
The latter format is useful for cluster recoveries that take multiple days.
You can use the cat health API to verify cluster health across multiple nodes.
You also can use the API to track the recovery of a large cluster over a longer period of time.
monitorThe unit used to display time values.
Values are nanos, micros, ms, s, m, h, or d.
If true, returns HH:MM:SS and Unix epoch timestamps.
A comma-separated list of columns names to display. It supports simple wildcards.
Supported values include:
epoch (or t, time): The number of seconds since 1970-01-01 00:00:00.timestamp (or ts, hms, hhmmss): The time in HH:MM:SS format.cluster (or cl): The cluster name.status (or st): The health status.node.total (or nt, nodeTotal): The total number of nodes that can store data.node.data (or nd, nodeData): The number of nodes that can store data.shards (or t, sh, shards.total, shardsTotal): The total number of shards.pri (or p, shards.primary, shardsPrimary): The number of primary shards.relo (or r, shards.relocating, shardsRelocating): The number of relocating nodes.init (or i, shards.initializing, shardsInitializing): The number of initializing nodes.unassign (or u, shards.unassigned, shardsUnassigned): The number of unassigned shards.unassign.pri (or up, shards.unassigned.primary, shardsUnassignedPrimary): The number of unassigned primary shards.pending_tasks (or pt, pendingTasks): The number of pending tasks.max_task_wait_time (or mtwt, maxTaskWaitTime): The wait time of the longest pending task.active_shards_percent (or asp, activeShardsPercent): The percentage of active shards.Values are epoch, t, time, timestamp, ts, hms, hhmmss, cluster, cl, status, st, node.total, nt, nodeTotal, node.data, nd, nodeData, shards, sh, shards.total, shardsTotal, pri, p, shards.primary, shardsPrimary, relo, r, shards.relocating, shardsRelocating, init, i, shards.initializing, shardsInitializing, unassign, u, shards.unassigned, shardsUnassigned, unassign.pri, up, shards.unassigned.primary, shardsUnassignedPrimary, pending_tasks, pt, pendingTasks, max_task_wait_time, mtwt, maxTaskWaitTime, active_shards_percent, asp, or activeShardsPercent.
List of columns that determine how the table should be sorted.
Sorting defaults to ascending and can be changed by setting :asc
or :desc as a suffix to the column name.
GET /_cat/health?v=true&format=json
resp = client.cat.health(
v=True,
format="json",
)const response = await client.cat.health({
v: "true",
format: "json",
});response = client.cat.health(
v: "true",
format: "json"
)$resp = $client->cat()->health([
"v" => "true",
"format" => "json",
]);curl -X GET -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_cat/health?v=true&format=json"[
{
"epoch": "1475871424",
"timestamp": "16:17:04",
"cluster": "elasticsearch",
"status": "green",
"node.total": "1",
"node.data": "1",
"shards": "1",
"pri": "1",
"relo": "0",
"init": "0",
"unassign": "0",
"unassign.pri": "0",
"pending_tasks": "0",
"max_task_wait_time": "-",
"active_shards_percent": "100.0%"
}
]curl \
--request GET 'http://api.example.com/_cat' \
--header "Authorization: $API_KEY"All methods and paths for this operation:
Get high-level information about indices in a cluster, including backing indices for data streams.
Use this request to get the following information for each index in a cluster:
These metrics are retrieved directly from Lucene, which Elasticsearch uses internally to power indexing and search. As a result, all document counts include hidden nested documents. To get an accurate count of Elasticsearch documents, use the cat count or count APIs.
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 an index endpoint.
monitormonitorComma-separated list of data streams, indices, and aliases used to limit the request.
Supports wildcards (*). To target all data streams and indices, omit this parameter or use * or _all.
The unit used to display byte values.
Values are b, kb, mb, gb, tb, or pb.
The type of index that wildcard patterns can match.
Supported values include:
all: Match any data stream or index, including hidden ones.open: Match open, non-hidden indices. Also matches any non-hidden data stream.closed: Match closed, non-hidden indices. Also matches any non-hidden data stream. Data streams cannot be closed.hidden: Match hidden data streams and hidden indices. Must be combined with open, closed, or both.none: Wildcard expressions are not accepted.Values are all, open, closed, hidden, or none.
The health status used to limit returned indices. By default, the response includes indices of any health status.
Supported values include:
green (or GREEN): All shards are assigned.yellow (or YELLOW): All primary shards are assigned, but one or more replica shards are unassigned. If a node in the cluster fails, some data could be unavailable until that node is repaired.red (or RED): One or more primary shards are unassigned, so some data is unavailable. This can occur briefly during cluster startup as primary shards are assigned.unknownunavailableValues are green, GREEN, yellow, YELLOW, red, RED, unknown, or unavailable.
If true, the response includes information from segments that are not loaded into memory.
If true, the response only includes information from primary shards.
The unit used to display time values.
Values are nanos, micros, ms, s, m, h, or d.
Period to wait for a connection to the master node.
Values are -1 or 0.
A comma-separated list of columns names to display. It supports simple wildcards.
Supported values include:
health (or h): The current health status.status (or s): The open/close status.index (or i, idx): The index name.uuid (or id, uuid): The index UUID.pri (or p, shards.primary, shardsPrimary): The number of primary shards.rep (or r, shards.replica, shardsReplica): The number of replica shards.docs.count (or dc, docsCount): The number of available documents.docs.deleted (or dd, docsDeleted): The number of deleted documents.creation.date (or cd): The index creation date (millisecond value).creation.date.string (or cds): The index creation date (as string).store.size (or ss, storeSize): The store size of primaries and replicas.pri.store.size: The store size of primaries.dataset.size: The total size of the dataset.completion.size (or cs, completionSize): The size of completion for primaries and replicas.pri.completion.size: The size of completion for primaries.fielddata.memory_size (or fm, fielddataMemory): The used fielddata cache for primaries and replicas.pri.fielddata.memory_size: The used fielddata cache for primaries.fielddata.evictions (or fe, fielddataEvictions): The number of fielddata evictions for primaries and replicas.pri.fielddata.evictions: The number of fielddata evictions for primaries.query_cache.memory_size (or qcm, queryCacheMemory): The used query cache for primaries and replicas.pri.query_cache.memory_size: The used query cache for primaries.query_cache.evictions (or qce, queryCacheEvictions): The number of query cache evictions for primaries and replicas.pri.query_cache.evictions: The number of query cache evictions for primaries.request_cache.memory_size (or rcm, requestCacheMemory): The used request cache for primaries and replicas.pri.request_cache.memory_size: The used request cache for primaries.request_cache.evictions (or rce, requestCacheEvictions): The number of request cache evictions for primaries and replicas.pri.request_cache.evictions: The number of request cache evictions for primaries.request_cache.hit_count (or rchc, requestCacheHitCount): The request cache hit count for primaries and replicas.pri.request_cache.hit_count: The request cache hit count for primaries.request_cache.miss_count (or rcmc, requestCacheMissCount): The request cache miss count for primaries and replicas.pri.request_cache.miss_count: The request cache miss count for primaries.flush.total (or ft, flushTotal): The number of flushes for primaries and replicas.pri.flush.total: The number of flushes for primaries.flush.total_time (or ftt, flushTotalTime): The time spent in flush for primaries and replicas.pri.flush.total_time: The time spent in flush for primaries.get.current (or gc, getCurrent): The number of current get operations for primaries and replicas.pri.get.current: The number of current get operations for primaries.get.time (or gti, getTime): The time spent in get for primaries and replicas.pri.get.time: The time spent in get for primaries.get.total (or gto, getTotal): The number of get operations for primaries and replicas.pri.get.total: The number of get operations for primaries.get.exists_time (or geti, getExistsTime): The time spent in successful gets for primaries and replicas.pri.get.exists_time: The time spent in successful gets for primaries.get.exists_total (or geto, getExistsTotal): The number of successful gets for primaries and replicas.pri.get.exists_total: The number of successful gets for primaries.get.missing_time (or gmti, getMissingTime): The time spent in failed gets for primaries and replicas.pri.get.missing_time: The time spent in failed gets for primaries.get.missing_total (or gmto, getMissingTotal): The number of failed gets for primaries and replicas.pri.get.missing_total: The number of failed gets for primaries.indexing.delete_current (or idc, indexingDeleteCurrent): The number of current deletions for primaries and replicas.pri.indexing.delete_current: The number of current deletions for primaries.indexing.delete_time (or idti, indexingDeleteTime): The time spent in deletions for primaries and replicas.pri.indexing.delete_time: The time spent in deletions for primaries.indexing.delete_total (or idto, indexingDeleteTotal): The number of delete operations for primaries and replicas.pri.indexing.delete_total: The number of delete operations for primaries.indexing.index_current (or iic, indexingIndexCurrent): The number of current indexing operations for primaries and replicas.pri.indexing.index_current: The number of current indexing operations for primaries.indexing.index_time (or iiti, indexingIndexTime): The time spent in indexing for primaries and replicas.pri.indexing.index_time: The time spent in indexing for primaries.indexing.index_total (or iito, indexingIndexTotal): The number of indexing operations for primaries and replicas.pri.indexing.index_total: The number of indexing operations for primaries.indexing.index_failed (or iif, indexingIndexFailed): The number of failed indexing operations for primaries and replicas.pri.indexing.index_failed: The number of failed indexing operations for primaries.indexing.index_failed_due_to_version_conflict (or iifvc, indexingIndexFailedDueToVersionConflict): The number of failed indexing operations due to version conflict for primaries and replicas.pri.indexing.index_failed_due_to_version_conflict: The number of failed indexing operations due to version conflict for primaries.merges.current (or mc, mergesCurrent): The number of current merges for primaries and replicas.pri.merges.current: The number of current merges for primaries.merges.current_docs (or mcd, mergesCurrentDocs): The number of current merging documents for primaries and replicas.pri.merges.current_docs: The number of current merging documents for primaries.merges.current_size (or mcs, mergesCurrentSize): The size of current merges for primaries and replicas.pri.merges.current_size: The size of current merges for primaries.merges.total (or mt, mergesTotal): The number of completed merge operations for primaries and replicas.pri.merges.total: The number of completed merge operations for primaries.merges.total_docs (or mtd, mergesTotalDocs): The number of merged documents for primaries and replicas.pri.merges.total_docs: The number of merged documents for primaries.merges.total_size (or mts, mergesTotalSize): The merged size for primaries and replicas.pri.merges.total_size: The merged size for primaries.merges.total_time (or mtt, mergesTotalTime): The time spent in merges for primaries and replicas.pri.merges.total_time: The time spent in merges for primaries.refresh.total (or rto, refreshTotal): The total refreshes for primaries and replicas.pri.refresh.total: The total refreshes for primaries.refresh.time (or rti, refreshTime): The time spent in refreshes for primaries and replicas.pri.refresh.time: The time spent in refreshes for primaries.refresh.external_total (or rto, refreshTotal): The total external refreshes for primaries and replicas.pri.refresh.external_total: The total external refreshes for primaries.refresh.external_time (or rti, refreshTime): The time spent in external refreshes for primaries and replicas.pri.refresh.external_time: The time spent in external refreshes for primaries.refresh.listeners (or rli, refreshListeners): The number of pending refresh listeners for primaries and replicas.pri.refresh.listeners: The number of pending refresh listeners for primaries.search.fetch_current (or sfc, searchFetchCurrent): The current fetch phase operations for primaries and replicas.pri.search.fetch_current: The current fetch phase operations for primaries.search.fetch_time (or sfti, searchFetchTime): The time spent in fetch phase for primaries and replicas.pri.search.fetch_time: The time spent in fetch phase for primaries.search.fetch_total (or sfto, searchFetchTotal): The total fetch operations for primaries and replicas.pri.search.fetch_total: The total fetch operations for primaries.search.open_contexts (or so, searchOpenContexts): The open search contexts for primaries and replicas.pri.search.open_contexts: The open search contexts for primaries.search.query_current (or sqc, searchQueryCurrent): The current query phase operations for primaries and replicas.pri.search.query_current: The current query phase operations for primaries.search.query_time (or sqti, searchQueryTime): The time spent in query phase for primaries and replicas.pri.search.query_time: The time spent in query phase for primaries.search.query_total (or sqto, searchQueryTotal): The total query phase operations for primaries and replicas.pri.search.query_total: The total query phase operations for primaries.search.scroll_current (or scc, searchScrollCurrent): The open scroll contexts for primaries and replicas.pri.search.scroll_current: The open scroll contexts for primaries.search.scroll_time (or scti, searchScrollTime): The time scroll contexts held open for primaries and replicas.pri.search.scroll_time: The time scroll contexts held open for primaries.search.scroll_total (or scto, searchScrollTotal): The completed scroll contexts for primaries and replicas.pri.search.scroll_total: The completed scroll contexts for primaries.segments.count (or sc, segmentsCount): The number of segments for primaries and replicas.pri.segments.count: The number of segments for primaries.segments.memory (or sm, segmentsMemory): The memory used by segments for primaries and replicas.pri.segments.memory: The memory used by segments for primaries.segments.index_writer_memory (or siwm, segmentsIndexWriterMemory): The memory used by index writer for primaries and replicas.pri.segments.index_writer_memory: The memory used by index writer for primaries.segments.version_map_memory (or svmm, segmentsVersionMapMemory): The memory used by version map for primaries and replicas.pri.segments.version_map_memory: The memory used by version map for primaries.segments.fixed_bitset_memory (or sfbm, fixedBitsetMemory): The memory used by fixed bit sets for nested object field types and type filters for types referred in _parent fields. Applicable for primaries and replicas.pri.segments.fixed_bitset_memory: The memory used by fixed bit sets for nested object field types and type filters for types referred in _parent fields. Applicable for primaries.warmer.current (or wc, warmerCurrent): The current warmer operations for primaries and replicas.pri.warmer.current: The current warmer operations for primaries.warmer.total (or wto, warmerTotal): The total warmer operations for primaries and replicas.pri.warmer.total: The total warmer operations for primaries.warmer.total_time (or wtt, warmerTotalTime): The time spent in warmers for primaries and replicas.pri.warmer.total_time: The time spent in warmers for primaries.suggest.current (or suc, suggestCurrent): The current suggest operations for primaries and replicas.pri.suggest.current: The current suggest operations for primaries.suggest.time (or suti, suggestTime): The time spent in suggest for primaries and replicas.pri.suggest.time: The time spent in suggest for primaries.suggest.total (or suto, suggestTotal): The number of suggest operations for primaries and replicas.pri.suggest.total: The number of suggest operations for primaries.memory.total (or tm, memoryTotal): The total used memory for primaries and replicas.pri.memory.total: The total used memory for primaries.bulk.total_operations (or bto, bulkTotalOperation): The number of bulk shard operations for primaries and replicas.pri.bulk.total_operations: The number of bulk shard operations for primaries.bulk.total_time (or btti, bulkTotalTime): The time spent in shard bulk for primaries and replicas.pri.bulk.total_time: The time spent in shard bulk for primaries.bulk.total_size_in_bytes (or btsi, bulkTotalSizeInBytes): The total size in bytes of shard bulk for primaries and replicas.pri.bulk.total_size_in_bytes: The total size in bytes of shard bulk for primaries.bulk.avg_time (or bati, bulkAvgTime): The average time spent in shard bulk for primaries and replicas.pri.bulk.avg_time: The average time spent in shard bulk for primaries.bulk.avg_size_in_bytes (or basi, bulkAvgSizeInBytes): The average size in bytes of shard bulk for primaries and replicas.pri.bulk.avg_size_in_bytes: The average size in bytes of shard bulk for primaries.dense_vector.value_count (or dvc, denseVectorCount): The total count of indexed dense vectors for primaries and replicas.pri.dense_vector.value_count: The total count of indexed dense vectors for primaries.sparse_vector.value_count (or svc, sparseVectorCount): The total count of indexed sparse vectors for primaries and replicas.pri.sparse_vector.value_count: The total count of indexed sparse vectors for primaries.Values are health, h, status, s, index, i, idx, uuid, id, pri, p, shards.primary, shardsPrimary, rep, r, shards.replica, shardsReplica, docs.count, dc, docsCount, docs.deleted, dd, docsDeleted, creation.date, cd, creation.date.string, cds, store.size, ss, storeSize, pri.store.size, dataset.size, completion.size, cs, completionSize, pri.completion.size, fielddata.memory_size, fm, fielddataMemory, pri.fielddata.memory_size, fielddata.evictions, fe, fielddataEvictions, pri.fielddata.evictions, query_cache.memory_size, qcm, queryCacheMemory, pri.query_cache.memory_size, query_cache.evictions, qce, queryCacheEvictions, pri.query_cache.evictions, request_cache.memory_size, rcm, requestCacheMemory, pri.request_cache.memory_size, request_cache.evictions, rce, requestCacheEvictions, pri.request_cache.evictions, request_cache.hit_count, rchc, requestCacheHitCount, pri.request_cache.hit_count, request_cache.miss_count, rcmc, requestCacheMissCount, pri.request_cache.miss_count, flush.total, ft, flushTotal, pri.flush.total, flush.total_time, ftt, flushTotalTime, pri.flush.total_time, get.current, gc, getCurrent, pri.get.current, get.time, gti, getTime, pri.get.time, get.total, gto, getTotal, pri.get.total, get.exists_time, geti, getExistsTime, pri.get.exists_time, get.exists_total, geto, getExistsTotal, pri.get.exists_total, get.missing_time, gmti, getMissingTime, pri.get.missing_time, get.missing_total, gmto, getMissingTotal, pri.get.missing_total, indexing.delete_current, idc, indexingDeleteCurrent, pri.indexing.delete_current, indexing.delete_time, idti, indexingDeleteTime, pri.indexing.delete_time, indexing.delete_total, idto, indexingDeleteTotal, pri.indexing.delete_total, indexing.index_current, iic, indexingIndexCurrent, pri.indexing.index_current, indexing.index_time, iiti, indexingIndexTime, pri.indexing.index_time, indexing.index_total, iito, indexingIndexTotal, pri.indexing.index_total, indexing.index_failed, iif, indexingIndexFailed, pri.indexing.index_failed, indexing.index_failed_due_to_version_conflict, iifvc, indexingIndexFailedDueToVersionConflict, pri.indexing.index_failed_due_to_version_conflict, merges.current, mc, mergesCurrent, pri.merges.current, merges.current_docs, mcd, mergesCurrentDocs, pri.merges.current_docs, merges.current_size, mcs, mergesCurrentSize, pri.merges.current_size, merges.total, mt, mergesTotal, pri.merges.total, merges.total_docs, mtd, mergesTotalDocs, pri.merges.total_docs, merges.total_size, mts, mergesTotalSize, pri.merges.total_size, merges.total_time, mtt, mergesTotalTime, pri.merges.total_time, refresh.total, rto, refreshTotal, pri.refresh.total, refresh.time, rti, refreshTime, pri.refresh.time, refresh.external_total, pri.refresh.external_total, refresh.external_time, pri.refresh.external_time, refresh.listeners, rli, refreshListeners, pri.refresh.listeners, search.fetch_current, sfc, searchFetchCurrent, pri.search.fetch_current, search.fetch_time, sfti, searchFetchTime, pri.search.fetch_time, search.fetch_total, sfto, searchFetchTotal, pri.search.fetch_total, search.open_contexts, so, searchOpenContexts, pri.search.open_contexts, search.query_current, sqc, searchQueryCurrent, pri.search.query_current, search.query_time, sqti, searchQueryTime, pri.search.query_time, search.query_total, sqto, searchQueryTotal, pri.search.query_total, search.scroll_current, scc, searchScrollCurrent, pri.search.scroll_current, search.scroll_time, scti, searchScrollTime, pri.search.scroll_time, search.scroll_total, scto, searchScrollTotal, pri.search.scroll_total, segments.count, sc, segmentsCount, pri.segments.count, segments.memory, sm, segmentsMemory, pri.segments.memory, segments.index_writer_memory, siwm, segmentsIndexWriterMemory, pri.segments.index_writer_memory, segments.version_map_memory, svmm, segmentsVersionMapMemory, pri.segments.version_map_memory, segments.fixed_bitset_memory, sfbm, fixedBitsetMemory, pri.segments.fixed_bitset_memory, warmer.current, wc, warmerCurrent, pri.warmer.current, warmer.total, wto, warmerTotal, pri.warmer.total, warmer.total_time, wtt, warmerTotalTime, pri.warmer.total_time, suggest.current, suc, suggestCurrent, pri.suggest.current, suggest.time, suti, suggestTime, pri.suggest.time, suggest.total, suto, suggestTotal, pri.suggest.total, memory.total, tm, memoryTotal, pri.memory.total, bulk.total_operations, bto, bulkTotalOperation, pri.bulk.total_operations, bulk.total_time, btti, bulkTotalTime, pri.bulk.total_time, bulk.total_size_in_bytes, btsi, bulkTotalSizeInBytes, pri.bulk.total_size_in_bytes, bulk.avg_time, bati, bulkAvgTime, pri.bulk.avg_time, bulk.avg_size_in_bytes, basi, bulkAvgSizeInBytes, pri.bulk.avg_size_in_bytes, dense_vector.value_count, dvc, denseVectorCount, pri.dense_vector.value_count, sparse_vector.value_count, svc, sparseVectorCount, or pri.sparse_vector.value_count.
List of columns that determine how the table should be sorted.
Sorting defaults to ascending and can be changed by setting :asc
or :desc as a suffix to the column name.
GET /_cat/indices/my-index-*?v=true&s=index&format=json
resp = client.cat.indices(
index="my-index-*",
v=True,
s="index",
format="json",
)const response = await client.cat.indices({
index: "my-index-*",
v: "true",
s: "index",
format: "json",
});response = client.cat.indices(
index: "my-index-*",
v: "true",
s: "index",
format: "json"
)$resp = $client->cat()->indices([
"index" => "my-index-*",
"v" => "true",
"s" => "index",
"format" => "json",
]);curl -X GET -H "Authorization: ApiKey $ELASTIC_API_KEY" "$ELASTICSEARCH_URL/_cat/indices/my-index-*?v=true&s=index&format=json"[
{
"health": "yellow",
"status": "open",
"index": "my-index-000001",
"uuid": "u8FNjxh8Rfy_awN11oDKYQ",
"pri": "1",
"rep": "1",
"docs.count": "1200",
"docs.deleted": "0",
"store.size": "88.1kb",
"pri.store.size": "88.1kb",
"dataset.size": "88.1kb"
},
{
"health": "green",
"status": "open",
"index": "my-index-000002",
"uuid": "nYFWZEO7TUiOjLQXBaYJpA ",
"pri": "1",
"rep": "0",
"docs.count": "0",
"docs.deleted": "0",
"store.size": "260b",
"pri.store.size": "260b",
"dataset.size": "260b"
}
]