API client / Methods / Manage indices

Jun. 08, 2023

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.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

We released a new version of the PHP API client in public beta. Read the beta documentation for more information.

We released a new version of the JavaScript API client in public beta. Read the beta documentation for more information.

We released a new version of the Java API client in public beta. Read the beta documentation for more information.

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

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

About this method

Copy an index, including its records, synonyms, rules, and settings.

You can copy the entire index (records, settings, Synonyms, and Rules) or one or more of the following scopes:

Settings
Synonyms
Rules

This method does not copy the enableReRanking setting.

Rate limiting

Copying an index is rate-limited:

If you have more than 100 pending requests, your requests are throttled.
If you have more than 5,000 pending requests, further requests are ignored.

Source indices

Copying a source index that doesn’t exist creates a new index with 0 records.

Destination indices

Within the same Algolia application: destination indices are overwritten. Everything besides the API keys and Analytics data is replaced.

Between applications (API clients): copying an index fails if the destination index exists.

Between applications (CLI): objects (records, synonyms, rules) with the same objectID, and existing settings, are replaced in the destination index. Objects with different objectID are added to the index.

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. You can’t 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

To copy parts of your source index, use the scope parameter. If you omit the scope parameter, everything is copied.

For example, to copy an index’s settings and synonyms, but not records and rules, set the scope parameter to: ["settings", "synonyms"].

The scope is replaced completely. Different items belonging to the same scope are not merged. For example, with scope: "settings", all settings of the destination index are replaced with the settings of the source index.
Items in different scopes are preserved.
If you set the scope parameter, records aren’t copied.

Examples

Read the Algolia CLI documentation for more information.

To see a complete app, including all import and setup instructions, go to Install the .NET API client.

To see a complete app, including all import and setup instructions, go to Install the Go API client.

To see a complete app, including all import and setup instructions, go to Install the Java API client.

To see a complete app, including all import and setup instructions, go to Install the Kotlin API client.

To see a complete app, including all import and setup instructions, go to Install the Scala API client.

To see a complete app, including all import and setup instructions, go to Install the Swift API client.

Copy an index

Copy

1
2
3
4
5
6
7
8
9
10
11
<?php
require_once __DIR__."/vendor/autoload.php";
use Algolia\AlgoliaSearch\SearchClient;

// Use an API key with `addObject` ACL
$client = SearchClient::create(
  'YourApplicationID', 'YourAPIKey'
);

// Copy `indexNameSrc` to `indexNameDest`
$client->copyIndex('indexNameSrc', 'indexNameDest');

1
2
3
4
5
6
7
8
9
require 'algolia'

# Use an API key with `addObject` ACL
client = Algolia::Search::Client.create(
  'YourApplicationID', 'YourAPIKey'
)

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

1
2
3
4
5
6
7
const algoliasearch = require('algoliasearch');

// Use an API key with `addObject` ACL
const client = algoliasearch('YourApplicationID', 'YourAPIKey');

// Copy `indexNameSrc` to `indexNameDest`
client.copyIndex('indexNameSrc', 'indexNameDest');

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

# Use an API key with `addObject` ACL
client = SearchClient.create("YourApplicationID", "YourAPIKey")

# Copy `indexNameSrc` to `indexNameDest`
client.copy_index("indexNameSrc", "indexNameDest")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import AlgoliaSearchClient

// Use an API key with `addObject` ACL
let client = SearchClient(
  appID: "YourApplicationID",
  apiKey: "YourAPIKey"
)

// 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
6
7
8
// Use an API key with `addObject` ACL
val client = ClientSearch(
  ApplicationID("YourApplicationID")
  APIKey("YourAPIKey")
)
// Copy `indexNameSrc` to `indexNameDest`
val index = client.initIndex(IndexName("indexNameSrc"))
index.copyIndex(IndexName("indexNameDest"))

1
2
3
4
5
6
7
8
// Use an API key with `addObject` ACL
var client = new SearchClient("YourApplicationID", "YourAPIKey");

// Copy `indexNameSrc` to `indexNameDest`
client.CopyIndex("indexNameSrc", "indexNameDest");

// Asynchronous
await client.CopyIndexAsync("indexNameSrc", "indexNameDest");

1
2
3
4
5
6
7
8
// Use an API key with `addObject` ACL
SearchClient client = DefaultSearchClient.create("YourApplicationID", "YourAPIKey");

// Copy `indexNameSrc` to `indexNameDest`
client.copyIndex("indexNameSrc", "indexNameDest");

// Asynchronous
client.copyIndexAsync("indexNameSrc", "indexNameDest");

1
2
3
4
5
// Use an API key with `addObject` ACL
client := search.NewClient("YourApplicationID", "YourAPIKey")

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

1
2
3
4
5
// Use an API key with `addObject` ACL
val client = new AlgoliaClient("YourApplicationID", "YourAPIKey")

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

Copy parts of an index with scopes

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
require_once __DIR__."/vendor/autoload.php";
use Algolia\AlgoliaSearch\SearchClient;

// Use an API key with `addObject` ACL
$client = SearchClient::create(
  'YourApplicationID', 'YourAPIKey'
);

// Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
$client->copyIndex('indexNameSrc', 'indexNameDest', [
  'scope' => ['settings', 'synonyms']
]);

1
2
3
4
5
6
7
8
9
10
11
require 'algolia'

# Use an API key with `addObject` ACL
client = Algolia::Search::Client.create(
  'YourApplicationID', 'YourAPIKey'
)

# Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
client.copy_index('indexNameSrc', 'indexNameDest', {
  scope: ['settings', 'synonyms']
})

1
2
3
4
// Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
client.copyIndex('indexNameSrc', 'indexNameDest', {
  scope: ['settings', 'synonyms']
});

1
2
3
4
5
6
7
8
9
from algoliasearch.search_client import SearchClient

# Use an API key with `addObject` ACL
client = SearchClient.create("YourApplicationID", "YourAPIKey")

# Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
client.copy_index("indexNameSrc", "indexNameDest", {
    "scope": ["settings", "synonyms"]
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import AlgoliaSearchClient

// Use an API key with `addObject` ACL
let client = SearchClient(
  appID: "YourApplicationID",
  apiKey: "YourAPIKey"
)

// Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
client.copyIndex(
  from: "indexNameSrc",
  to: "indexNameDest",
  scope: [Scope.settings, Scope.synonyms]
)

1
2
3
4
5
6
7
8
9
10
11
12
13
// Use an API key with `addObject` ACL
val client = ClientSearch(
  ApplicationID("YourApplicationID"),
  APIKey("YourAPIKey")
)

// Copy only synonyms and settings from `indexNameSrc` to `indexNameDest`
val index = client.initIndex(IndexName("indexNameSrc"))
val scopes = listOf(
    Scope.Settings,
    Scope.Synonyms
)
index.copyIndex(IndexName("indexNameDest"), scopes)

1
2
3
4
5
6
7
8
9
10
11
12
13
// Use an API key with `addObject` ACL
var client = new SearchClient("YourApplicationID", "YourAPIKey");

// Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
List<string> scopes = new List<string>() {
    CopyScope.Settings,
    CopyScope.Synonyms
};

client.CopyIndex("indexNameSrc","indexNameDest",scope: scopes);

// Asynchronous
client.CopyIndexAsync("indexNameSrc","indexNameDest",scope: scopes);

1
2
3
4
5
6
7
8
// Use an API key with `addObject` ACL
SearchClient client = DefaultSearchClient.create("YourApplicationID", "YourAPIKey");

// Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
client.copyIndex(
  "indexNameSrc", "indexNameDest",
  Arrays.asList("settings", "synonyms")
);

1
2
3
4
5
6
7
8
9
// Use an API key with `addObject` ACL
client := search.NewClient("YourApplicationID", "YourAPIKey")

// Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
res, err := client.CopyIndex(
  "indexNameSrc",
  "indexNameDest",
  opt.Scopes("settings", "synonyms"),
)

1
2
3
4
5
6
7
// Use an API key with `addObject` ACL
val client = new AlgoliaClient("YourApplicationID", "YourAPIKey")

// Copy only settings and synonyms from `indexNameSrc` to `indexNameDest`
client.execute {
  copy index "indexNameSrc" to "indexNameDest" scopes Seq("settings", "synonyms")
}

1
2
3
# Copy only settings and synonyms from `INDEX_NAME_SRC` to `INDEX_NAME_DEST`
algolia index copy INDEX_NAME_SRC INDEX_NAME_DEST \
        --scopes "settings,synonyms"

Copy index between apps

Copy

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

// Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
$sourceIndex = SearchClient::create('SOURCE_APP_ID', 'SOURCE_API_KEY')->initIndex('indexNameSrc');
$targetIndex = SearchClient::create('TARGET_APP_ID', 'TARGET_API_KEY')->initIndex('indexNameDest');

// This method returns an error if `$targetIndex` exists
AccountClient::copyIndex($sourceIndex, $targetIndex);

1
2
3
4
5
6
7
8
9
10
11
12
require 'algolia'

# Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
source_index = Algolia::Search::Client.create(
  'SOURCE_APP_ID', 'SOURCE_API_KEY'
).init_index('indexNameSrc')
target_index = Algolia::Search::Client.create(
  'TARGET_APP_ID', 'TARGET_API_KEY'
).init_index('indexNameDest')

# This method returns an error if `target_index` exists
Algolia::Account::Client.copy_index(source_index, target_index)

1
2
3
4
5
6
7
8
9
10
const algoliasearch = require('algoliasearch');
// Extra package: `npm install @algolia/client-account`
const accountCopyIndex = require('@algolia/client-account').accountCopyIndex;

// Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
const sourceIndex = algoliasearch('SOURCE_APP_ID', 'SOURCE_API_KEY').initIndex('indexNameSrc');
const targetIndex = algoliasearch('TARGET_APP_ID', 'TARGET_API_KEY').initIndex('indexNameDest');

// This method returns an error if `targetIndex` exists
accountCopyIndex(sourceIndex, targetIndex);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from algoliasearch.search_client import SearchClient
from algoliasearch.account_client import AccountClient

# Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
source_index = SearchClient.create(
    "SOURCE_APP_ID", "SOURCE_API_KEY"
).init_index("indexNameSrc")

target_index = SearchClient.create(
    "TARGET_APP_ID", "TARGET_API_KEY"
).init_index("indexNameDest")

# This method throws an exception if `target_index` exists
AccountClient.copy_index(source_index, target_index)

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

// Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
let sourceIndex = SearchClient(appID: "SOURCE_APP_ID", apiKey: "SOURCE_API_KEY").index(withName: "indexNameSrc")
let targetIndex = SearchClient(appID: "TARGET_APP_ID", apiKey: "TARGET_API_KEY").index(withName: "indexNameDest")

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
val sourceIndex = ClientSearch(
    ApplicationID("SOURCE_APP_ID"),
    APIKey("SOURCE_API_KEY")
).initIndex(IndexName("indexNameSrc"))

val targetIndex = ClientSearch(
    ApplicationID("TARGET_APP_ID"),
    APIKey("TARGET_API_KEY")
).initIndex(IndexName("indexNameDest"))

// This method throws an exception if `targetIndex` exists
ClientAccount.copyIndex(sourceIndex, targetIndex)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
SearchClient sourceClient = new SearchClient("SOURCE_APP_ID", "SOURCE_API_KEY");
SearchClient targetClient = new SearchClient("TARGET_APP_ID", "TARGET_API_KEY");

SearchIndex sourceIndex = sourceClient.InitIndex("indexNameSrc");
SearchIndex targetIndex = targetClient.InitIndex("indexNameDest");

AccountClient accountClient = new AccountClient();

// Provide your 'Record' class for serializing the records during copying
// This method throws an exception if `targetIndex` exists
accountClient.CopyIndex<Record>(sourceIndex, targetIndex);

// Asynchronous
await accountClient.CopyIndexAsync<Record>(sourceIndex, targetIndex);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
SearchClient sourceClient =
  DefaultSearchClient.create("SOURCE_APP_ID", "SOURCE_API_KEY");

SearchIndex<Record> sourceIndex =
  sourceClient.initIndex("indexNameSrc", Record.class);

SearchClient targetClient =
DefaultSearchClient.create("TARGET_APP_ID", "TARGET_API_KEY");

SearchIndex<Record> targetIndex =
  targetClient.initIndex("indexNameDest", Record.class);

AccountClient accountClient = new AccountClient();

// This method throws an exception, if `targetIndex` exists
accountClient.copyIndex(sourceIndex, targetIndex);

// Asynchronous
accountClient.copyIndexAsync(sourceIndex, destinationIndex);

1
2
3
4
5
// Copy `indexNameSrc` from app `SOURCE_APP_ID` to app `TARGET_APP_ID`
sourceIndex = search.NewClient("SOURCE_APP_ID", "SOURCE_API_KEY").InitIndex("indexNameSrc")
targetIndex = search.NewClient("TARGET_APP_ID", "TARGET_API_KEY").InitIndex("indexNameDest")

res, err := search.NewAccount().CopyIndex(sourceIndex, targetIndex)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Copy records from `INDEX_NAME_SRC` of the profile `SOURCE` to `INDEX_NAME_DEST` of the profile `TARGET`
algolia --profile SOURCE objects browse INDEX_NAME_SRC \
| algolia --profile TARGET objects import INDEX_NAME_DEST --file -

# Copy settings
algolia --profile SOURCE settings get INDEX_NAME_SRC \
| algolia --profile TARGET settings import INDEX_NAME_DEST --file -

# Copy synonyms
algolia --profile SOURCE synonyms browse INDEX_NAME_SRC \
| algolia --profile TARGET synonyms import INDEX_NAME_DEST --file -

# Copy Rules
algolia --profile SOURCE rules browse INDEX_NAME_SRC \
| algolia --profile TARGET rules import INDEX_NAME_DEST --file -

Parameters

Parameter	Description
`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

This section shows the JSON response returned by the API. Each API client encapsulates this response inside objects specific to the programming language, so that the actual response might be different. You can view the response by using the getLogs method. Don’t rely on the order of attributes in the response, as JSON doesn’t guarantee the ordering of keys in objects.

JSON format

Copy

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

        

Field Description

Field	Description
`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.


          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.

Did you find this page helpful?

Copy index

About this method

Rate limiting

Source indices

Destination indices

API keys

Analytics

Replicas

Scopes

Examples

Copy an index

Copy parts of an index with scopes

Copy index between apps

Parameters

Response

JSON format

On this page