API Reference / API Methods / Manage indices / Copy index

Nov. 12, 2020

Copy Index

Required API Key: any key with the addObject ACL

Method signature

$client->copyIndex(
  string indexNameSrc,
  string indexNameDest
)
$client->copyIndex(
  string indexNameSrc,
  string indexNameDest,
  [
    'scope' => array
  ]
);

// Copy index in between apps
\Algolia\AlgoliaSearch\AccountClient::copyIndex(
  SearchIndex indexSrc,
  SearchIndex indexDest
);

client.copy_index(
  String indexNameSrc,
  String indexNameDest
)
client.copy_index(
  String indexNameSrc,
  String indexNameDest,
  Hash opts = {
    Array scope = ['settings', 'synonyms', 'rules']
  }
)

# Copy index in between apps
Algolia::Account::Client.copy_index(
  Index indexSrc,
  Index indexDest
)

client.copyIndex(
  string indexNameSrc,
  string indexNameDest
)
client.copyIndex(
  string indexNameSrc,
  string indexNameDest,
  {
    scope => array
  }
)

client.copy_index(str indexNameSrc, str indexNameDest)
client.copy_index(str indexNameSrc, str indexNameDest, {
    'scope' => list
})

# Copy index in between apps
from algoliasearch.account_client import AccountClient

AccountClient.copy_index(
    Index indexSrc,
    Index indexDest
)

client.copyIndex(
  from source: IndexName,
  to destination: IndexName,
  scope: Scope = .all,
  requestOptions: RequestOptions? = nil,
  completion: Result<WaitableWrapper<IndexRevision>> -> Void
)

ClientAccount.copyIndex(
  source: Index,
  destination: Index,
  requestOptions: RequestOptions? = nil,
  completion: Result<WaitableWrapper<[Task]>, Swift.Error>) -> Void
)

suspend fun IndexcopyIndex(
    destination: IndexName,
    scopes: List<Scope>? = null,
    requestOptions: RequestOptions? = null
): RevisionIndex

suspend fun ClientAccount.copyIndex(
    source: Index,
    destination: Index
): List<Task>

client.copyIndexAsync(
  String indexNameSrc,
  String indexNameDest,
  null
)
// scope is not available in mobile API clients

client.CopyIndex(
  String indexNameSrc,
  String indexNameDest,

  // All the following parameters are optional
  scope: IEnumerable<String>
)

// Copy index in between apps
client.CopyIndex(
  SearchIndex indexNameSrc,
  SearchIndex indexNameDest,
)

client.copyIndex(
  String indexNameSrc,
  String indexNameDest
)
client.copyIndex(
  String indexNameSrc,
  String indexNameDest,
  List<String> scope
)

client.CopyIndex(
  String indexNameSrc,
  String indexNameDest
)
client.CopyIndex(
  String indexNameSrc,
  String indexNameDest,
  opt.Scopes([]String scope...),
)

// Copy index between apps
accountClient.CopyIndex(
  index indexSrc,
  index indexDest
)

copy index indexNameSrc to indexNameDest
copy index indexNameSrc to indexNameDest scope scope

See code examples

About this method

You are currently reading the JavaScript API client v4 documentation. Check our migration guide to learn how to upgrade from v3 to v4. You can still access the v3 documentation.

You are currently reading the Ruby API client v2 documentation. Check our migration guide to learn how to upgrade from v1 to v2. You can still access the v1 documentation.

Make a copy of an index, including its records, settings, Synonyms, and Rules.

With this method you can copy the entire index (records, settings, Synonyms, and Rules) or any subset of the following:

settings,
Synonyms,
and Rules.

Use the scope parameter to determine what you want to copy.

Copy operations overwrite destination indices. This means that everything besides the API keys and the Analytics data is lost.

Copying is an expensive operation:

When you have more than 100 pending requests, they’re automatically throttled.
When you have more than 5000 pending requests, further requests are ignored.

If needed, you can configure these limits.

Before performing a copy 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 perform a waitTask for this job, the wait will never resolve.

API keys

The API keys of the source are merged with the existing keys in the destination index.

Analytics

Copying an index has no impact on Analytics, because you cannot copy an index’s analytics data.

Replicas

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

You can’t copy to a destination index that already has replicas.

Scopes

Using the scope parameter, you can copy specific parts of your source index .

If you omit the scope parameter, then everything is copied. If you use it, you’re copying specific scopes rather than records.

For example, if you specify "settings" and "synonyms", you’re copying your source index’s settings and Synonyms, but ignoring its Rules and records. On the other hand, if you don’t specify a scope (that is, you omit the scope parameter) then the copy command works as by default: copying all records, settings, Synonyms, and Rules.

Copied items fully replace the corresponding scopes in the destination index. The engine doesn’t do any kind of merging of items that belong to the same scope, it fully overwrites them.

Whenever you use the scope parameter, the engine preserves items belonging to scopes that weren’t copied. For example, if you’re copying to an index that already has records, and you specify "settings" and "synonyms" as the scope, the engine will preserve the existing records in the destination index.

Examples

Copy an index

Copy

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

1
2
3
4
5
6
// Copy indexNameSrc to indexNameDest
client.copyIndex(from: "indexNameSrc", to: "indexNameDest") { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

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

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

Copy resources between indices

Copy

1
2
3
4
// Copy settings and synonyms (but not rules, nor records) from indexNameSrc to indexNameDest
$res = $client->copyIndex('indexNameSrc', 'indexNameDest', [
  'scope' => ['settings', 'synonyms']
]);

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

1
2
3
4
5
6
// Copy settings and synonyms (but not rules) from "indexNameSrc" to "indexNameDest".
client.copyIndex('indexNameSrc', 'indexNameDest', {
  scope: ['settings', 'synonyms']
}).then(() => {
  // done
});

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

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")
}

Copy index between apps

Copy

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
client_1 = Algolia::Search::Client.create('APP_ID_1', 'API_KEY_1')
index_1 = client_1.init_index('index_name_1')

client_2 = Algolia::Search::Client.create('APP_ID_2', 'API_KEY_2')
index_2 = client_2.init_index('index_name_2')

Algolia::Account::Client.copy_index(index_1, index_2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// in CommonJS
const algoliasearch = require('algoliasearch');
const accountCopyIndex = require('@algolia/client-account').accountCopyIndex;

// in ES Modules
import algoliasearch from 'algoliasearch';
import { accountCopyIndex } from '@algolia/client-account';

const index1 = algoliasearch('APP_ID_1', 'API_KEY_1').initIndex('index_name_1');
const index2 = algoliasearch('APP_ID_2', 'API_KEY_2').initIndex('index_name_2');

accountCopyIndex(index1, index2).then(() => {
  // done
});

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
let index1 = SearchClient(appID: "APP_ID_1", apiKey: "API_KEY_1").index(withName: "index1")
let index2 = SearchClient(appID: "APP_ID_2", apiKey: "API_KEY_2").index(withName: "index2")

try AccountClient.copyIndex(source: index1, destination: index2) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

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(sourceIndex, destinationIndex);

// Async
AccountClient.copyIndexAsync(sourceIndex, destinationIndex);

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 client2 = 
DefaultSearchClient.create("APP_ID_2", "API_KEY_2");

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

AccountClient.copyIndex(sourceIndex, destinationIndex)

// Async
AccountClient.copyIndexAsync(sourceIndex, destinationIndex);

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)

Parameters

`indexNameSrc`	type: string Required Name of the source index to copy.
`indexNameDest`	type: string Required Name of the destination index.
`indexSrc`	type: object Required Source index object.
`indexDest`	type: object Required Destination index object.
`scope`	type: list Optional An array containing any combination of the following strings: `settings` `synonyms` `rules` See more on how this parameter works.

Response

In this section we document the JSON response returned by the API. Each language will encapsulate this response inside objects specific to the language and/or the implementation. So the actual type in your language might differ from what is documented.

JSON format

Copy
{
  "updatedAt": "2017-12-18T21:22:40.761Z",
  "taskID": 19541511530
}


          updatedAt

date string

Date at which the job to copy the index has been created.


          taskID

integer

This is the taskID which is used with the waitTask method.

Note: You can use either the source or destination index to wait on the resulting taskID. In either case, the wait will include the full copy process.

Building Search UI

Building Search UI

Building Search UI

Building Search UI

Building Search UI

Building Search UI

PHP

Ruby

JavaScript

Python

Swift

Kotlin

Android

.NET

Java

Golang

Scala

InstantSearch.js

React InstantSearch

Vue InstantSearch

Angular InstantSearch

InstantSearch iOS

InstantSearch Android

Autocomplete

Crawler Configuration API

Index settings and search parameters

A full reference of API Endpoints

Rails

Symfony

Django

Laravel

Crawler

Magento 2

WordPress

Shopify

Salesforce Commerce Cloud B2C

Netlify

Copy Index

About this method

API keys

Analytics

Replicas

Scopes

Examples

Copy an index

Copy resources between indices

Copy index between apps

Parameters

Response

JSON format

Did you find this page helpful?

On this page