---
type: api
title: Get information about all currently running reindex tasks
description: Reindex tasks that are mid-relocation between nodes are reported once,
url: https://www.elastic.co/elastic/docs-builder/docs/4371/api/doc/elasticsearch/operation/operation-list-reindex
resource: https://www.elastic.co/elastic/docs-builder/docs/4371/api/doc/elasticsearch/operation/operation-list-reindex
products:
  - Elasticsearch
---

# Get information about all currently running reindex tasks

Availability: 9.5+

## Paths

- `GET` `/_reindex`

- [Api key auth](/elastic/docs-builder/docs/4371/api/doc/elasticsearch/authentication#apikeyauth)
- [Basic auth](/elastic/docs-builder/docs/4371/api/doc/elasticsearch/authentication#basicauth)
- [Bearer auth](/elastic/docs-builder/docs/4371/api/doc/elasticsearch/authentication#bearerauth)

## Description

Reindex tasks that are mid-relocation between nodes are reported once,
under their original task ID, so callers do not see duplicates across the relocation chain.

If the API returns a HTTP status of `200 OK`, but `node_failures` or `task_failures` are non-empty in the body, the listing is not a complete authoritative listing and may be missing tasks.

## Query String Parameters

- `detailed` (boolean · default: false)
  If `true`, include detailed task status information in the response.

## Response

`application/json`

- `reindex` ([] ReindexTaskInfo)
  The list of currently running reindex tasks.
  - `id` (string TaskId)
    The ID of the reindex task. The ID is assigned when the task was first created and remains the same across graceful shutdown relocations.
  - `description` (string)
    A sanitized description of the reindex operation (source and destination indices, and optionally remote host info).
  - `start_time_in_millis` (EpochTimeUnitMillis)
    The time at which the reindex task started, in milliseconds since the Unix epoch. Remains the same across graceful shutdown relocations.
  - `start_time` (string)
    The time at which the reindex task started, as an ISO-8601 formatted string. Remains the same across graceful shutdown relocations.
Only present when the request includes the `?human=true` query parameter.
  - `running_time` (string Duration)
    The elapsed running time of the reindex task, including relocations, in a human-readable format.
Only present when the request includes the `?human=true` query parameter.
  - `running_time_in_nanos` (DurationValueUnitNanos)
    The elapsed running time of the reindex task, including relocations, in nanoseconds.
  - `cancelled` (boolean)
    Whether the reindex task has been cancelled.
  - `status` ({} ReindexStatus)
    The current progress of the reindex operation.
    - `slice_id` (number)
      The slice ID
    - `batches` (number)
      The number of scroll responses pulled back by the reindex.
    - `created` (number)
      The number of documents that were successfully created.
    - `deleted` (number)
      The number of documents that were successfully deleted.
    - `noops` (number)
      The number of documents that were ignored because the script used for the reindex returned a `noop` value for `ctx.op`.
    - `requests_per_second` (number)
      The number of requests per second effectively executed during the reindex.
    - `retries` ({} Retries)
      The number of retries attempted by reindex. `bulk` is the number of bulk actions retried and `search` is the number of search actions retried.
      - `bulk` (number)
        The number of bulk actions retried.
      - `search` (number)
        The number of search actions retried.
    - `throttled` (string Duration)
    - `throttled_millis` (DurationValueUnitMillis)
      Number of milliseconds the request slept to conform to `requests_per_second`.
    - `throttled_until` (string Duration)
    - `throttled_until_millis` (DurationValueUnitMillis)
      This field should always be equal to zero in a `_reindex` response.
It only has meaning when using the Task API, where it indicates the next time (in milliseconds since epoch) a throttled request will be executed again in order to conform to `requests_per_second`.
    - `total` (number)
      The number of documents that were successfully processed.
    - `updated` (number)
      The number of documents that were successfully updated, for example, a document with same ID already existed prior to reindex updating it.
    - `version_conflicts` (number)
      The number of version conflicts that reindex hits.
    - `cancelled` (string)
      The reason for cancellation if the slice was canceled
- `task_failures` ([] TaskFailure)
  Per-task failures encountered while listing reindex tasks. Tasks that failed are not included in the `reindex` array.
  - `task_id` (number)
  - `node_id` (string)
  - `status` (string)
  - `reason` ({} ErrorCause)
    - `type` (string)
      The type of error
    - `reason` (union string) — nullable
      A human-readable explanation of the error, in English.
      One of: `string`
    - `stack_trace` (string)
      The server stack trace. Present only if the `error_trace=true` parameter was sent with the request.
    - `caused_by` ({} ErrorCause) — recursive
      Same fields as `reason` in `task_failures`
    - `root_cause` ([] ErrorCause) — recursive
      Same fields as `reason` in `task_failures`
    - `suppressed` ([] ErrorCause) — recursive
      Same fields as `reason` in `task_failures`
- `node_failures` ([] ErrorCause)
  Node-level failures encountered while listing reindex tasks.
Typically populated when a node disconnects or stops responding mid-request,
reindex tasks running on such nodes will be missing from the `reindex` array for the duration of the disruption.
  - `type` (string)
    The type of error
  - `reason` (union string) — nullable
    A human-readable explanation of the error, in English.
    One of: `string`
  - `stack_trace` (string)
    The server stack trace. Present only if the `error_trace=true` parameter was sent with the request.
  - `caused_by` ({} ErrorCause) — recursive
    Same fields as `node_failures`
  - `root_cause` ([] ErrorCause) — recursive
    Same fields as `node_failures`
  - `suppressed` ([] ErrorCause) — recursive
    Same fields as `node_failures`
## Code Examples

#### Console

```console
GET _reindex
```

#### JavaScript

```javascript
const response = await client.listReindex();
```

#### Python

```python
resp = client.list_reindex()
```

#### curl

```curl
curl -X GET "$ELASTICSEARCH_URL/_reindex" \
  -H "Authorization: ApiKey $ELASTIC_API_KEY"
```

#### Java

```java
client.listReindex(l -> l);
```

#### C#

```c#
var response = await client.ListReindexAsync();
```

#### PHP

```php
$resp = $client->listReindex();
```

#### Ruby

```ruby
response = client.list_reindex
```

## Response Examples

#### One running task

A successful response from `GET _reindex` listing a single currently running reindex task.

```json
{
  "reindex": [
    {
      "id": "r1A2WoRbTwKZ516z6NEs5A:36619",
      "start_time_in_millis": 1762190000000,
      "running_time_in_nanos": 4200000000,
      "cancelled": false
    }
  ]
}
```

#### One running task with detailed status

A successful response from `GET _reindex?detailed=true&human=true`, including the per-task `status` block.

```json
{
  "reindex": [
    {
      "id": "r1A2WoRbTwKZ516z6NEs5A:36619",
      "description": "reindex from [my-source-index] to [my-dest-index]",
      "start_time_in_millis": 1762190000000,
      "start_time": "2025-11-03T17:13:20.000Z",
      "running_time_in_nanos": 4200000000,
      "running_time": "4.2s",
      "cancelled": false,
      "status": {
        "batches": 4,
        "deleted": 0,
        "noops": 0,
        "requests_per_second": -1.0,
        "retries": {
          "bulk": 0,
          "search": 0
        },
        "throttled_millis": 0,
        "throttled_until_millis": 0,
        "total": 11500,
        "updated": 0,
        "version_conflicts": 0,
        "created": 4000
      }
    }
  ]
}
```

#### Partial list with node failure (HTTP 200)

`GET _reindex` always returns `200 OK`. If a node stops responding during the listing call, `node_failures` may be populated and tasks that were running on that node can be missing from `reindex` for that response. You may retry.

```json
{
  "reindex": [
    {
      "id": "r1A2WoRbTwKZ516z6NEs5A:36619",
      "start_time_in_millis": 1762190000000,
      "running_time_in_nanos": 4200000000,
      "cancelled": false
    }
  ],
  "node_failures": [
    {
      "type": "failed_node_exception",
      "reason": "Failed node [xNqz7mM2RkqY8vP1nL0wQ]",
      "node_id": "xNqz7mM2RkqY8vP1nL0wQ",
      "caused_by": {
        "type": "node_not_connected_exception",
        "reason": "Node not connected",
        "node_id": "xNqz7mM2RkqY8vP1nL0wQ"
      }
    }
  ]
}
```

