Guides / Sending and managing data / Manage indices and apps / Manage indices

Jan 13, 2025

Copy and move indices

Move or rename indices

You can move or rename an index within the same Algolia application in the Algolia dashboard or with an API client.

Rename indices in the Algolia dashboard

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Search.
Select your Algolia index:
Select Manage index > Rename.

The Rename option only shows if you selected a primary index. It doesn’t show for replica indices.
Enter the current and new index names and click Rename.

If an index with the new name already exists, it’s overwritten.

Rename indices with an API client

To rename or move an index with the API, you can use:

API clients: operationIndex
Algolia CLI: algolia indices move

You can’t move an index between different Algolia applications but you can create a copy and delete the original index. For more information, see Copy indices between apps.

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using Algolia.Search.Clients;
using Algolia.Search.Http;
using Algolia.Search.Models.Search;

var client = new SearchClient(new SearchConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY"));

var response = await client.OperationIndexAsync(
  "<SOURCE_INDEX_NAME>",
  new OperationIndexParams
  {
    Operation = Enum.Parse<OperationType>("Move"),
    Destination = "<DESTINATION_INDEX_NAME>",
  }
);

1
2
3
4
5
6
7
8
9
10
11
12
import 'package:algolia_client_search/algolia_client_search.dart';

final client =
    SearchClient(appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

final response = await client.operationIndex(
  indexName: "<SOURCE_INDEX_NAME>",
  operationIndexParams: OperationIndexParams(
    operation: OperationType.fromJson("move"),
    destination: "<DESTINATION_INDEX_NAME>",
  ),
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import "github.com/algolia/algoliasearch-client-go/v4/algolia/search"

client, err := search.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
if err != nil {
  // The client can fail to initialize if you pass an invalid parameter.
  panic(err)
}

response, err := client.OperationIndex(client.NewApiOperationIndexRequest(
  "<SOURCE_INDEX_NAME>",
  search.NewEmptyOperationIndexParams().SetOperation(search.OperationType("move")).SetDestination("<DESTINATION_INDEX_NAME>")))
if err != nil {
  // handle the eventual error
  panic(err)
}

1
2
3
4
5
6
7
8
9
import com.algolia.api.SearchClient;
import com.algolia.config.*;

SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

client.operationIndex(
  "<SOURCE_INDEX_NAME>",
  new OperationIndexParams().setOperation(OperationType.MOVE).setDestination("<DESTINATION_INDEX_NAME>")
);

1
2
3
4
5
6
7
8
9
import { algoliasearch } from 'algoliasearch';

//
const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

const response = await client.operationIndex({
  indexName: '<SOURCE_INDEX_NAME>',
  operationIndexParams: { operation: 'move', destination: '<DESTINATION_INDEX_NAME>' },
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import com.algolia.client.api.SearchClient
import com.algolia.client.configuration.*
import com.algolia.client.transport.*
import com.algolia.client.extensions.*

val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

var response = client.operationIndex(
  indexName = "<SOURCE_INDEX_NAME>",
  operationIndexParams = OperationIndexParams(
    operation = OperationType.entries.first { it.value == "move" },
    destination = "<DESTINATION_INDEX_NAME>",
  ),
)

1
2
3
4
5
6
7
8
9
10
use Algolia\AlgoliaSearch\Api\SearchClient;

$client = SearchClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

$response = $client->operationIndex(
    '<SOURCE_INDEX_NAME>',
    ['operation' => 'move',
        'destination' => '<DESTINATION_INDEX_NAME>',
    ],
);

1
2
3
4
5
6
7
8
9
10
11
12
13
from algoliasearch.search.client import SearchClientSync
from json import loads

# In an asynchronous context, you can use SearchClient instead, which exposes the exact same methods.
client = SearchClientSync("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

response = client.operation_index(
    index_name="<SOURCE_INDEX_NAME>",
    operation_index_params={
        "operation": "move",
        "destination": "<DESTINATION_INDEX_NAME>",
    },
)

1
2
3
4
5
6
7
8
require "algolia"

client = Algolia::SearchClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

response = client.operation_index(
  "<SOURCE_INDEX_NAME>",
  Algolia::Search::OperationIndexParams.new(operation: "move", destination: "<DESTINATION_INDEX_NAME>")
)

1
2
3
4
5
6
7
8
9
10
11
12
13
import algoliasearch.api.SearchClient
import algoliasearch.config.*
import algoliasearch.extension.SearchClientExtensions

val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

val response = client.operationIndex(
  indexName = "<SOURCE_INDEX_NAME>",
  operationIndexParams = OperationIndexParams(
    operation = OperationType.withName("move"),
    destination = "<DESTINATION_INDEX_NAME>"
  )
)

1
2
3
4
5
6
7
8
9
10
11
import Search

let client = try SearchClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")

let response = try await client.operationIndex(
    indexName: "<SOURCE_INDEX_NAME>",
    operationIndexParams: OperationIndexParams(
        operation: OperationType.move,
        destination: "<DESTINATION_INDEX_NAME>"
    )
)

If an index with the new name already exists, moving overwrites it. To avoid overwriting existing indices, check if an index exists with the indexExists helper.

If the source index doesn’t exist, Algolia ignores the move operation.

Renaming an index doesn’t change the associated analytics:

Analytics associated with the original index keep their name.
A new set of analytics is started with the new name.

For more information, see Indices and analytics.

Indices with replicas

Renaming replica indices requires several steps.

You can’t move a source index with replicas.

You can move an index to a destination index with replicas. First, the source index data replaces the destination index data. Then, the data is copied to the replicas.

If an index is the data source for Recommend models, you can’t rename it directly. If you do, you’ll lose the relationship between the recommended records and their source.

Instead:

Copy the index.
To keep the events you already collected, train a new model on the copy index using the old index as an additional events source.
After training, switch your apps and services to use the new index.
Delete the old index and the old model (from the Algolia dashboard).

Copy indices

You can copy an index in the Algolia dashboard or with an API client but be aware that:

Copying an index duplicates the records and configuration, including synonyms and rules of an existing index (except the enableReRanking setting).
Copying an index doesn’t create a replica. The new index is an independent copy.
To copy an index between two Algolia applications, you must use the API.

Copy indices in the Algolia dashboard

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Search.
Select your Algolia index:
Select Manage index > Duplicate.
Select Create a new index or Overwrite an existing index and enter the destination index name.
If you’re overwriting an existing index, enter DUPLICATE to confirm.
Click Duplicate.

Copy indices with an API client

To copy indices, you can use:

API clients: operationIndex
Algolia CLI: algolia indices copy

Provide a scope parameter to choose what you want to copy: records, settings, synonyms, or rules.

Copy indices fully

To copy an index including records, settings, synonyms, and rules:

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using Algolia.Search.Clients;
using Algolia.Search.Http;
using Algolia.Search.Models.Search;

var client = new SearchClient(new SearchConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY"));

var response = await client.OperationIndexAsync(
  "<SOURCE_INDEX_NAME>",
  new OperationIndexParams
  {
    Operation = Enum.Parse<OperationType>("Copy"),
    Destination = "<DESTINATION_INDEX_NAME>",
  }
);

1
2
3
4
5
6
7
8
9
10
11
12
import 'package:algolia_client_search/algolia_client_search.dart';

final client =
    SearchClient(appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

final response = await client.operationIndex(
  indexName: "<SOURCE_INDEX_NAME>",
  operationIndexParams: OperationIndexParams(
    operation: OperationType.fromJson("copy"),
    destination: "<DESTINATION_INDEX_NAME>",
  ),
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import "github.com/algolia/algoliasearch-client-go/v4/algolia/search"

client, err := search.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
if err != nil {
  // The client can fail to initialize if you pass an invalid parameter.
  panic(err)
}

response, err := client.OperationIndex(client.NewApiOperationIndexRequest(
  "<SOURCE_INDEX_NAME>",
  search.NewEmptyOperationIndexParams().SetOperation(search.OperationType("copy")).SetDestination("<DESTINATION_INDEX_NAME>")))
if err != nil {
  // handle the eventual error
  panic(err)
}

1
2
3
4
5
6
7
8
9
import com.algolia.api.SearchClient;
import com.algolia.config.*;

SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

client.operationIndex(
  "<SOURCE_INDEX_NAME>",
  new OperationIndexParams().setOperation(OperationType.COPY).setDestination("<DESTINATION_INDEX_NAME>")
);

1
2
3
4
5
6
7
8
9
import { algoliasearch } from 'algoliasearch';

//
const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

const response = await client.operationIndex({
  indexName: '<SOURCE_INDEX_NAME>',
  operationIndexParams: { operation: 'copy', destination: '<DESTINATION_INDEX_NAME>' },
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import com.algolia.client.api.SearchClient
import com.algolia.client.configuration.*
import com.algolia.client.transport.*
import com.algolia.client.extensions.*

val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

var response = client.operationIndex(
  indexName = "<SOURCE_INDEX_NAME>",
  operationIndexParams = OperationIndexParams(
    operation = OperationType.entries.first { it.value == "copy" },
    destination = "<DESTINATION_INDEX_NAME>",
  ),
)

1
2
3
4
5
6
7
8
9
10
use Algolia\AlgoliaSearch\Api\SearchClient;

$client = SearchClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

$response = $client->operationIndex(
    '<SOURCE_INDEX_NAME>',
    ['operation' => 'copy',
        'destination' => '<DESTINATION_INDEX_NAME>',
    ],
);

1
2
3
4
5
6
7
8
9
10
11
12
13
from algoliasearch.search.client import SearchClientSync
from json import loads

# In an asynchronous context, you can use SearchClient instead, which exposes the exact same methods.
client = SearchClientSync("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

response = client.operation_index(
    index_name="<SOURCE_INDEX_NAME>",
    operation_index_params={
        "operation": "copy",
        "destination": "<DESTINATION_INDEX_NAME>",
    },
)

1
2
3
4
5
6
7
8
require "algolia"

client = Algolia::SearchClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

response = client.operation_index(
  "<SOURCE_INDEX_NAME>",
  Algolia::Search::OperationIndexParams.new(operation: "copy", destination: "<DESTINATION_INDEX_NAME>")
)

1
2
3
4
5
6
7
8
9
10
11
12
13
import algoliasearch.api.SearchClient
import algoliasearch.config.*
import algoliasearch.extension.SearchClientExtensions

val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

val response = client.operationIndex(
  indexName = "<SOURCE_INDEX_NAME>",
  operationIndexParams = OperationIndexParams(
    operation = OperationType.withName("copy"),
    destination = "<DESTINATION_INDEX_NAME>"
  )
)

1
2
3
4
5
6
7
8
9
10
11
import Search

let client = try SearchClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")

let response = try await client.operationIndex(
    indexName: "<SOURCE_INDEX_NAME>",
    operationIndexParams: OperationIndexParams(
        operation: OperationType.copy,
        destination: "<DESTINATION_INDEX_NAME>"
    )
)

If the source index doesn’t exist, an empty index is created.
If an index with this name already exists, it will be overwritten.

To prevent overwriting existing indices, check if an index exists with the indexExists helper.

Copy indices partially

To copy parts of an index, use the scope parameter of the operationIndex method. For example, to copy only the synonyms and settings between indices, but not records or rules:

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
var response = await client.OperationIndexAsync(
  "<SOURCE_INDEX_NAME>",
  new OperationIndexParams
  {
    Operation = Enum.Parse<OperationType>("Move"),
    Destination = "<DESTINATION_INDEX_NAME>",
    Scope = new List<ScopeType>
    {
      Enum.Parse<ScopeType>("Rules"),
      Enum.Parse<ScopeType>("Settings"),
    },
  }
);

1
2
3
4
5
6
7
8
9
10
11
final response = await client.operationIndex(
  indexName: "<SOURCE_INDEX_NAME>",
  operationIndexParams: OperationIndexParams(
    operation: OperationType.fromJson("move"),
    destination: "<DESTINATION_INDEX_NAME>",
    scope: [
      ScopeType.fromJson("rules"),
      ScopeType.fromJson("settings"),
    ],
  ),
);

1
2
3
4
5
6
7
8
response, err := client.OperationIndex(client.NewApiOperationIndexRequest(
  "<SOURCE_INDEX_NAME>",
  search.NewEmptyOperationIndexParams().SetOperation(search.OperationType("move")).SetDestination("<DESTINATION_INDEX_NAME>").SetScope(
    []search.ScopeType{search.ScopeType("rules"), search.ScopeType("settings")})))
if err != nil {
  // handle the eventual error
  panic(err)
}

1
2
3
4
5
6
7
client.operationIndex(
  "<SOURCE_INDEX_NAME>",
  new OperationIndexParams()
    .setOperation(OperationType.MOVE)
    .setDestination("<DESTINATION_INDEX_NAME>")
    .setScope(Arrays.asList(ScopeType.RULES, ScopeType.SETTINGS))
);

1
2
3
4
const response = await client.operationIndex({
  indexName: '<SOURCE_INDEX_NAME>',
  operationIndexParams: { operation: 'move', destination: '<DESTINATION_INDEX_NAME>', scope: ['rules', 'settings'] },
});

1
2
3
4
5
6
7
8
var response = client.operationIndex(
  indexName = "<SOURCE_INDEX_NAME>",
  operationIndexParams = OperationIndexParams(
    operation = OperationType.entries.first { it.value == "move" },
    destination = "<DESTINATION_INDEX_NAME>",
    scope = listOf(ScopeType.entries.first { it.value == "rules" }, ScopeType.entries.first { it.value == "settings" }),
  ),
)

1
2
3
4
5
6
7
8
9
10
11
$response = $client->operationIndex(
    '<SOURCE_INDEX_NAME>',
    ['operation' => 'move',
        'destination' => '<DESTINATION_INDEX_NAME>',
        'scope' => [
            'rules',

            'settings',
        ],
    ],
);

1
2
3
4
5
6
7
8
9
10
11
response = client.operation_index(
    index_name="<SOURCE_INDEX_NAME>",
    operation_index_params={
        "operation": "move",
        "destination": "<DESTINATION_INDEX_NAME>",
        "scope": [
            "rules",
            "settings",
        ],
    },
)

1
2
3
4
5
6
7
8
response = client.operation_index(
  "<SOURCE_INDEX_NAME>",
  Algolia::Search::OperationIndexParams.new(
    operation: "move",
    destination: "<DESTINATION_INDEX_NAME>",
    scope: ["rules", "settings"]
  )
)

1
2
3
4
5
6
7
8
val response = client.operationIndex(
  indexName = "<SOURCE_INDEX_NAME>",
  operationIndexParams = OperationIndexParams(
    operation = OperationType.withName("move"),
    destination = "<DESTINATION_INDEX_NAME>",
    scope = Some(Seq(ScopeType.withName("rules"), ScopeType.withName("settings")))
  )
)

1
2
3
4
5
6
7
8
let response = try await client.operationIndex(
    indexName: "<SOURCE_INDEX_NAME>",
    operationIndexParams: OperationIndexParams(
        operation: OperationType.move,
        destination: "<DESTINATION_INDEX_NAME>",
        scope: [ScopeType.rules, ScopeType.settings]
    )
)

If you use the scope parameter, records aren’t copied to the new index. Existing items of the scope are replaced. Items belonging to other scopes are preserved. For example, if you use the settings scope, only the settings are copied to the destination index, keeping the records, synonyms, and rules.

Indices with replicas

Copying a source index that has replicas copies the index’s data, but not its replicas. The destination index won’t have replicas.

You can’t copy to a destination index with replicas.

Copy indices between different applications

To copy an index between different Algolia applications, use the Algolia CLI.

Did you find this page helpful?

Copy and move indices

On this page

Move or rename indices

Rename indices in the Algolia dashboard

Rename indices with an API client

Indices with replicas

Copy indices

Copy indices in the Algolia dashboard

Copy indices with an API client

Copy indices fully

Copy indices partially

Indices with replicas

Copy indices between different applications

On this page

Copy and move indices

On this page

Move or rename indices

Rename indices in the Algolia dashboard

Rename indices with an API client

Indices with replicas

Indices used as a Recommend data source

Copy indices

Copy indices in the Algolia dashboard

Copy indices with an API client

Copy indices fully

Copy indices partially

Indices with replicas

Copy indices between different applications

On this page