API clients / Methods / Indexing

Mar 27, 2025

Replace all objects

Required API Key: any key with the addObject ACL

Method signature

$index->replaceAllObjects(array objects);

$index->replaceAllObjects(array objects, [
  'safe' => bool,
]);

index.replace_all_objects(Array objects)

index.replace_all_objects(Array objects, Hash opts = {
  bool safe: false
})

index.replace_all_objects!(Array objects)

index.replaceAllObjects(array objects)

index.replaceAllObjects(array objects, {
    safe: bool,
    // + any requestOptions
})

index.replace_all_objects(list | iterator objects)

index.replace_all_objects(list objects, {
    'safe' => bool
})

index.replaceAllObjects<T: Encodable>(
  with objects: [T],
  autoGeneratingObjectID: Bool = false,
  safe: Bool = false,
  requestOptions: RequestOptions? = nil,
  completion: Result<[IndexedTask]> -> Void
) throws

suspend fun Index.replaceAllObjects(
    records: List<JsonObject>
): List<Task>

suspend fun <T : Indexable> Index.replaceAllObjects(
    serializer: KSerializer<T>,
    records: List<T>
): List<Task>

index.ReplaceAllObjects(
  IEnumerable<T> objects,
  safe: bool
);

index.replaceAllObjects(Iterable<T> objects);
index.replaceAllObjects(Iterable<T> objects, Boolean safe);

index.ReplaceAllObjects([]Object objects, Boolean opts.Safe)

Not implemented.

See the Examples section.

See code examples

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

Replace all records from your index with a new set of records.

This method lets you replace all records in your index without downtime. It performs these operations:

Copy settings, synonyms, and rules from your original index to a temporary index.
Add your new records to the temporary index.
Replace your original index with the temporary index.

Use the safe parameter to ensure that these (asynchronous) operations are performed in sequence.
If there’s an error duing one of these steps, the temporary index won’t be deleted.
This operation is rate-limited.
This method creates a temporary index: your record count is temporarily doubled. Algolia doesn’t count the three days with the highest number of records towards your monthly usage.
If you’re on a legacy plan (before July 2020), this method counts two operations towards your usage (in addition to the number of records): copySettings and moveIndex.
The API key you use for this operation must have access to the index YourIndex and the temporary index YourIndex_tmp.

Examples

Read the Algolia CLI documentation for more information.

Replace all records

Copy

1
2
3
4
5
6
7
8
9
$client = Algolia\AlgoliaSearch\SearchClient::create(
  'YourApplicationID',
  'YourWriteAPIKey'
);

$objects = /* Fetch your objects */;

$index = $client->initIndex('YourIndexName');
$index->replaceAllObjects($objects);

1
2
3
4
5
6
7
8
client = Algolia::Search::Client.create('YourApplicationID', 'YourWriteAPIKey')

objects = [
  # your new objects
]

index = client.init_index('YourIndexName')
index.replace_all_objects(objects)

1
2
3
4
5
6
7
8
9
const client = algoliasearch('YourApplicationID', 'YourWriteAPIKey');

const objects = []; // Fetch your objects

const index = client.initIndex('YourIndexName');

index.replaceAllObjects(objects).then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
5
6
client = SearchClient.create("YourApplicationID", "YourWriteAPIKey")

objects = [] # Fetch your objects

index = client.init_index("YourIndexName")
index.replace_all_objects(objects)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct Contact: Encodable {
  let objectID: ObjectID
  let firstname: String
  let lastname: String
}

let client = SearchClient(appID: "YourApplicationID", apiKey: "YourWriteAPIKey")
let index = client.index(withName: "YourIndexName")

let objects: [Contact]! = [/*Fetch your objects*/]

index.replaceAllObjects(with: objects) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// With JsonObject
val json = listOf(
    json {
        "firstname" to "Jimmie"
        "lastname" to "Barninger"
    },
    json {
        "firstname" to "Warren"
        "lastname" to "Speach"
    }
)

index.replaceAllObjects(json)

// With serializable class
@Serializable
data class Contact(val firstname: String, val lastname: String)

val contacts = listOf(
    Contact("Jimmie", "Barninger"),
    Contact("Warren", "Speach")
)

index.replaceAllObjects(Contact.serializer(), contacts)

1
2
3
4
5
var client = new SearchClient("YourApplicationID", "YourWriteAPIKey");
var index = client.InitIndex("YourIndexName");

var objects = /* Fetch your objects */;
index.ReplaceAllObjects(objects);

1
2
3
4
5
6
7
8
9
10
11
12
13
SearchClient client =
DefaultSearchClient.create("YourApplicationID", "YourWriteAPIKey");

SearchIndex<Contact> index = client.initIndex("YourIndexName", Contact.class);

// Fetch your objects
List<Contact> objects = new ArrayList<>();

// Sync version
index.replaceAllObjects(objects);

// Async version
index.replaceAllObjectsAsync(objects);

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "github.com/algolia/algoliasearch-client-go/v3/algolia/search"

func main() {
    client := search.NewClient("YourApplicationID", "YourWriteAPIKey")
    index := client.InitIndex("YourIndexName")

    objects := []Object{ /* Fetch your objects */ }

    res, err := index.ReplaceAllObjects(objects)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import algolia.AlgoliaClient
import algolia.AlgoliaDsl._
import algolia.responses._

import scala.concurrent.duration._
import scala.concurrent.duration.FiniteDuration
import scala.concurrent.{Await, ExecutionContext, ExecutionContextExecutor, Future}

case class MyCaseClass(objectID: String, /* ... */) extends ObjectID

object Main {

  def main(args: Array[String]): Unit = {

    implicit val ec: ExecutionContextExecutor = ExecutionContext.global
    implicit val awaitDuration: FiniteDuration = 10 seconds

    val client = new AlgoliaClient("YourApplicationID", "YourWriteAPIKey")
    val tmpIndexName = "atomic_reindex_tmp"
    val indexName = "atomic_reindex"

    // 1. Copy the settings, synonyms and rules (but not the records)
    // of the target index into the temporary index
    val copyTask = Await.result(
      client.execute(copy index indexName to tmpIndexName scope Seq("settings", "synonyms", "rules")),
      awaitDuration
    )
    client.execute(waitFor task copyTask from indexName)

    // 2. Fetch your data and push it to the temporary index
    val objects: Seq[MyCaseClass] = Seq(/* ... */)

    // Here is where you push your data to the temporary index
    val batchTasks = Await.result(
      Future.sequence(objects.grouped(1000).map(batch => client.execute(index into tmpIndexName objects batch))),
      awaitDuration
    )

    Await.result(
      Future.sequence(batchTasks.map(task => client.execute(waitFor task task from tmpIndexName))),
      awaitDuration
    )

    // 3. Move the temporary index to the target index
    client.execute(move index tmpIndexName to indexName)
  }

}

Replace all records and wait for operations

Copy

1
2
3
4
5
6
7
8
9
10
11
$client = Algolia\AlgoliaSearch\SearchClient::create(
  'YourApplicationID',
  'YourWriteAPIKey'
);

$objects = /* Fetch your objects */;

$index = $client->initIndex('YourIndexName');
$index->replaceAllObjects($objects, [
  'safe' => true,
]);

1
2
3
4
5
6
7
8
9
client = Algolia::Search::Client.create('YourApplicationID', 'YourWriteAPIKey')

objects = [
  # your new objects
]

index = client.init_index('YourIndexName')
index.replace_all_objects(objects, { safe: true })
# or: index.replace_all_objects!(objects)

1
2
3
4
5
6
7
8
9
const client = algoliasearch('YourApplicationID', 'YourWriteAPIKey');

const objects = []; // Fetch your objects

const index = client.initIndex('YourIndexName');

index.replaceAllObjects(objects, { safe: true }).then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
5
6
7
8
client = SearchClient.create('YourApplicationID', 'YourWriteAPIKey')

objects = [] # Fetch your objects

index = client.init_index('YourIndexName')
index.replace_all_objects(objects, {
    'safe': True
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct Contact: Encodable {
  let objectID: ObjectID
  let firstname: String
  let lastname: String
}

let client = SearchClient(appID: "YourApplicationID", apiKey: "YourWriteAPIKey")
let index = client.index(withName: "YourIndexName")

let objects: [Contact]! = [/*Fetch your objects*/]

index.replaceAllObjects(with: objects, safe: true) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
client.apply {
  val json = listOf(
      json {
          "firstname" to "Jimmie"
          "lastname" to "Barninger"
      },
      json {
          "firstname" to "Warren"
          "lastname" to "Speach"
      }
  )

  index.replaceAllObjects(json).waitAll()
}

1
2
3
4
5
var client = new SearchClient("YourApplicationID", "YourWriteAPIKey");
var index = client.InitIndex("YourIndexName");

var objects = /* Fetch your objects */;
index.ReplaceAllObjects(objects, true);

1
2
3
4
5
6
7
8
9
SearchClient client =
DefaultSearchClient.create("YourApplicationID", "YourWriteAPIKey");

SearchIndex<Contact> index = client.initIndex("YourIndexName", Contact.class);

// Fetch your objects
List<Contact> objects = new ArrayList<>();

index.replaceAllObjects(objects, true);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
  "github.com/algolia/algoliasearch-client-go/v3/algolia/opt"
  "github.com/algolia/algoliasearch-client-go/v3/algolia/search"
)

func main() {
    client := search.NewClient("YourApplicationID", "YourWriteAPIKey")
    index := client.InitIndex("YourIndexName")

    objects := []Object{ /* Fetch your objects */ }

    res, err := index.ReplaceAllObjects(objects, opt.Safe(true))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import algolia.AlgoliaClient
import algolia.AlgoliaDsl._
import algolia.responses._

import scala.concurrent.duration._
import scala.concurrent.duration.FiniteDuration
import scala.concurrent.{Await, ExecutionContext, ExecutionContextExecutor, Future}

case class MyCaseClass(objectID: String, /* ... */) extends ObjectID

object Main {

  def main(args: Array[String]): Unit = {

    implicit val ec: ExecutionContextExecutor = ExecutionContext.global
    implicit val awaitDuration: FiniteDuration = 10 seconds

    val client = new AlgoliaClient("YourApplicationID", "YourWriteAPIKey")
    val tmpIndexName = "atomic_reindex_tmp"
    val indexName = "atomic_reindex"

    // 1. Copy the settings, synonyms and rules (but not the records)
    // of the target index into the temporary index
    val copyTask = Await.result(
      client.execute(copy index indexName to tmpIndexName scope Seq("settings", "synonyms", "rules")),
      awaitDuration
    )
    client.execute(waitFor task copyTask from indexName)

    // 2. Fetch your data and push it to the temporary index
    val objects: Seq[MyCaseClass] = Seq(/* ... */)

    // Here is where you push your data to the temporary index
    val batchTasks = Await.result(
      Future.sequence(objects.grouped(1000).map(batch => client.execute(index into tmpIndexName objects batch))),
      awaitDuration
    )

    Await.result(
      Future.sequence(batchTasks.map(task => client.execute(waitFor task task from tmpIndexName))),
      awaitDuration
    )

    // 3. Move the temporary index to the target index
    client.execute(move index tmpIndexName to indexName)
  }

}

Parameters

`objects`	type: list Required List of records. Use an iterator instead of a list to prevent memory issues, especially if you want to replace many records.
`safe`	type: boolean default: false Optional If true, wait after each step before continuing.
`requestOptions`	type: key-value pairs Optional A mapping of request options to send along with the query.

Response

This method doesn't return a response.

Did you find this page helpful?