Copy Index

About this method

Make a copy of an index, including its objects, settings, synonyms, and query rules.

This method enables you to copy the entire index (objects, settings, synonyms, and rules) OR one or more of the following index elements:

• settings
• synonyms
• and rules (query rules)

You can control which of these are copied by using the scope parameter.

The copy command will overwrite the destination index. This means everything will be lost in the destination index except its API keys and Analytics data.

Regarding the API Keys, the source’s API Keys will be merged with the existing keys of the destination index.

Note this is an expensive operation:

• when you have more than 100 requests pending, your requests will be throttled.
• when you have more than 5000 requests pending, further requests will be ignored.
• if needed, these values can be tuned through configuration.

Copying an index will have no impact on analytics data because you cannot copy an index’s analytics data.

Regarding replicas:

• Copying an index having replicas is possible, but the replicas will not be copied, only the data. The destination index will not have replicas.
• Copying to a existing index having replicas is not possible.

Before performing this operation, make sure your source index exists. Our API creates a job even when an index doesn’t exist, but because it has no source index, the job won’t be able to end. If you wait for it to finish in your code, the wait will never resolve.

Examples

Copy an index

1
2
// Copy indexNameSrc to indexNameDest
$res = $client->copyIndex('indexNameSrc', 'indexNameDest');

1
2
# Copy indexNameSrc to indexNameDest
puts client.copy_index('indexNameSrc', 'indexNameDest')

1
2
3
4
5
6
// Copy indexNameSrc to indexNameDest
client.copyIndex('indexNameSrc', 'indexNameDest', (err, content) => {
  if (err) throw err;

  console.log(content);
});

1
2
# Copy indexNameSrc to indexNameDest
client.copy_index('indexNameSrc', 'indexNameDest')

1
2
3
4
5
6
7
8
9
10
11
12
// Copy indexNameSrc to indexNameDest
client.copyIndex(
  from: "indexNameSrc",
  to: "indexNameDest",
  completionHandler: { (content, error) -> Void in
    if error != nil {
        print("Copy failure: \(error!)")
    } else {
        print("Copy success: \(content!)")
    }
  }
)

1
2
// Copy indexNameSrc to indexNameDest
client.copyIndexAsync("indexNameSrc", "indexNameDest", null);

1
2
3
4
5
// Copy indexNameSrc to indexNameDest (synchronous)
client.CopyIndex("indexNameSrc", "indexNameDest");

// Copy indexNameSrc to indexNameDest (asynchronous)
await client.CopyIndexAsync("indexNameSrc", "indexNameDest");

1
2
3
4
5
// Sync version
client.copyIndex("indexNameSrc", "indexNameDest");

// Async version
client.copyIndexAsync("indexNameSrc", "indexNameDest");

1
2
// Copy indexNameSrc to indexNameDest
res, err := client.CopyIndex("indexNameSrc", "indexNameDest")

1
2
// Copy indexNameSrc to indexNameDest
client.execute { copy index "indexNameSrc" to "indexNameDest" }

1
index.copyIndex(indexName)

Copy resources between indices

1
2
3
4
// Copy settings and synonyms (but not rules, nor records) from the current index to "indexNameDest".
$index->copyTo('indexNameDest', [
  'scope' => ['settings', 'synonyms']
]);

1
2
# Copy settings and synonyms (but not rules) from "indexNameSrc" to "indexNameDest".
client.copy_index('indexNameSrc', 'indexNameDest', ['settings', 'synonyms'])

1
2
3
4
5
6
// Copy settings and synonyms (but not rules) from "indexNameSrc" to "indexNameDest".
client.copyIndex('indexNameSrc', 'indexNameDest', ['settings', 'synonyms'], (err, content) => {
  if (err) throw err;

  console.log(content);
});

1
2
3
4
# Copy settings and synonyms (but not rules) from "indexNameSrc" to "indexNameDest".
client.copy_index('indexNameSrc', 'indexNameDest', {
    'scope': ['settings', 'synonyms']
})

1
This method is not available in mobile API clients.

1
This method is not available in mobile API clients.

1
2
3
4
5
6
7
8
9
10
// Copy settings and synonyms (but not rules, nor records) from the current index to "indexNameDest".
List<CopyScope> scopes = new List<CopyScope>() {
  CopyScope.SETTINGS,
  CopyScope.SYNONYMS
};

index.CopyTo("indexNameDest", scope: scopes);

// Copy settings and synonyms (but not rules) from "indexNameSrc" to "indexNameDest" (synchronous)
index.CopyToAsync("indexNameDest", scope: scopes);

1
2
3
4
// Copy settings and synonyms (but not rules) from "indexNameSrc" to "indexNameDest"
client.copyIndex(
  "indexNameSrc", "indexNameDest", 
  Arrays.asList("settings", "synonyms"));

1
2
3
4
5
6
// Copy settings and synonyms (but not rules) from "indexNameSrc" to "indexNameDest".
res, err := client.CopyIndex(
  "indexNameSrc",
  "indexNameDest",
  opt.Scopes("settings", "synonyms"),
)

1
2
3
4
// Copy settings and synonyms (but not rules) from "indexNameSrc" to "indexNameDest".
client.execute {
  copy index "indexNameSrc" to "indexNameDest" scopes Seq("settings", "synonyms")
}

1
2
3
4
5
val scopes = listOf(
    Scope.Settings,
    Scope.Synonyms
)
index.copyIndex(indexName, scopes)

Copy index in between app

1
2
3
4
5
6
$index1 = \Algolia\AlgoliaSearch\SearchClient::create('APP_ID_1', 'API_KEY_1')
            ->initIndex('index_name_1');
$index2 = \Algolia\AlgoliaSearch\SearchClient::create('APP_ID_2', 'API_KEY_2')
            ->initIndex('index_name_2');

\Algolia\AlgoliaSearch\AccountClient::copyIndex($index1, $index2);

1
2
3
4
5
6
7
8
9
10
11
12
13
client_1 = Algolia::Client.new({
  :application_id => 'APP_ID_1',
  :api_key => 'API_KEY_1'
})
index_1 = client_1.init_index('index_name_1')

client_2 = Algolia::Client.new({
  :application_id => 'APP_ID_2',
  :api_key => 'API_KEY_2'
})
index_2 = client_2.init_index('index_name_2')

Algolia::AccountClient.copy_index(index_1, index_2)

1
2
3
4
5
6
7
from algoliasearch.search_client import SearchClient
from algoliasearch.account_client import AccountClient

index_1 = SearchClient.create('APP_ID_1', 'API_KEY_1').init_index('index_name_1')
index_2 = SearchClient.create('APP_ID_2', 'API_KEY_2').init_index('index_name_2')

AccountClient.copy_index(index_1, index_2)

1
2
3
4
5
6
7
8
9
10
SearchClient client1 = new SearchClient("APP_ID_1", "API_KEY_1");
SearchIndex sourceIndex = client1.initIndex("your_index_name");

SearchClient client2 = new SearchClient("APP_ID_2", "API_KEY_2");
SearchIndex destinationIndex = client2.initIndex("your_index_name");

AccountClient.copyIndex(index1, index2);

// Async
AccountClient.copyIndexAsync(index1, index2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
SearchClient client1 = 
DefaultSearchClient.create("APP_ID_1", "API_KEY_1");

SearchIndex<Contact> sourceIndex = 
  client1.initIndex("your_index_name", Contact.class);

SearchClient client1 = 
DefaultSearchClient.create("APP_ID_2", "API_KEY_2");

SearchIndex<Contact> destinationIndex = 
  client2.initIndex("your_index_name", Contact.class);

AccountClient.copyIndex(index1, index2)

// Async
AccountClient.copyIndexAsync(index1, index2);

1
2
3
4
index1 = search.NewClient("APP_ID_1", "API_KEY_1").InitIndex("index_name_1")
index2 = search.NewClient("APP_ID_2", "API_KEY_2").InitIndex("index_name_2")

g, err := search.NewAccount().CopyIndex(index1, index2)

1
2
3
4
5
6
7
8
9
10
11
val index1 = ClientSearch(
    applicationID = ApplicationID("APP_ID_1"),
    apiKey = APIKey("API_KEY_1")
).initIndex(IndexName("index1"))

val index2 = ClientSearch(
    applicationID = ApplicationID("APP_ID_2"),
    apiKey = APIKey("API_KEY_2")
).initIndex(IndexName("index2"))

ClientAccount.copyIndex(index1, index2)