API Reference / API Methods / Indexing / Custom batch

Nov. 12, 2020

Custom Batch

Required API Key: any key with the depends on operations performed inside the batch ACL

Method signature

$client->multipleBatch(array operations)
$client->multipleBatch(array operations, array requestOptions)

client.batch(Array operations)

client.batch(Array operations, Hash opts = {
  # any requestOptions
})

client.multipleBatch(array operations)

client.multipleBatch(array operations, {
  // + any requestOptions
})

client.multiple_batch(list operations)
client.multiple_batch(list operations, dict requestOptions)

client.batch(
  operations: [(IndexName, BatchOperation)],
  requestOptions: RequestOptions? = nil,
  completion: Result<WaitableWrapper<BatchesResponse>> -> Void
)

suspend fun ClientSearch.multipleBatchObjects(
    operations: List<BatchOperationIndex>,
    requestOptions: RequestOptions? = null
): ResponseBatches

client.batchAsync(JSONArray operations, null)
client.batchAsync(JSONArray operations, RequestOptions requestOptions, null)

client.MultipleBatch(
  IEnumerable<T> operations,

  // All the following parameters are optional
  requestOptions: RequestOptions
)

client.multipleBatch(
  List<BatchOperation> operations
)
client.multipleBatch(
  List<BatchOperation> operations,
  RequestOptions requestOptions
)

client.Batch(
  []BatchOperationIndexed operations
)
client.Batch(
  []BatchOperationIndexed operations,
  RequestOptions  requestOptions
)

batch(operations)
batch(operations) options requestOptions

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.

Perform several indexing operations in one API call.

This method enables you to batch multiple different indexing operations in one API call, like add or delete objects, potentially targeting multiple indices.

You would use this method to:

reduce latency - only one network trip is required for multiple operations
ensure data integrity - all operations inside the batch will be executed atomically. Meaning that instead of deleting 30 objects then adding 20 new objects in two operations, we do both operations in one go. This will remove the time during which an index is in an inconsistent state and could be a great alternative to doing an atomic reindexing using a temporary index.

When batching of a large numbers of objects, or large sizes, be aware of our rate limit. You’ll know you’ve reached the rate limit when you start receiving errors on your indexing operations. This can only be resolved if you wait before sending any further indexing operations.

Examples

Batch write operations

Copy

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
$res = $client->multipleBatch(
  [
    [
      'action'    => 'addObject',
      'indexName' => 'index1',
      'body'      => [
        'firstname' => 'Jimmie',
        'lastname'  => 'Barninger'
      ]
    ],
    [
      'action'    => 'updateObject',
      'indexName' => 'index1',
      'body'      => [
        'objectID' => 'myID2',
        'firstname' => 'Max',
        'lastname'  => 'Barninger'
      ]
    ],
    [
      'action'    => 'partialUpdateObject',
      'indexName' => 'index1',
      'body'      => [
        'objectID'  => 'myID3',
        'lastname'  => 'McFarway'
      ]
    ],
    [
      'action'    => 'partialUpdateObjectNoCreate',
      'indexName' => 'index1',
      'body'      => [
        'objectID'  => 'myID4',
        'firstname' => 'Warren'
      ]
    ],
    [
      'action'    => 'deleteObject',
      'indexName' => 'index2',
      'body'      => [
        'objectID'  => 'myID5'
      ]
    ]
  ]
);

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
res = client.batch([
  {
    'action': 'addObject',
    'indexName': 'index1',
    'body': {
      'firstname': 'Jimmie',
      'lastname': 'Barninger'
    }
  },
  {
    'action': 'updateObject',
    'indexName': 'index1',
    'body': {
      'objectID': 'myID2',
      'firstname': 'Max',
      'lastname': 'Barninger'
    }
  }
  {
    'action': 'partialUpdateObject',
    'indexName': 'index1',
    'body': {
      'objectID': 'myID3',
      'lastname': 'McFarway'
    }
  }
  {
    'action': 'partialUpdateObjectNoCreate',
    'indexName': 'index1',
    'body': {
      'objectID': 'myID4',
      'firstname': 'Warren'
    }
  }
  {
    'action': 'deleteObject',
    'indexName': 'index2',
    'body': {
      'objectID': 'myID5'
    }
  }
])

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
client.multipleBatch([
  {
    action: 'addObject',
    indexName: 'index1',
    body: {
      firstname: 'Jimmie',
      lastname: 'Barninger'
    }
  },
  {
    action: 'updateObject',
    indexName: 'index1',
    body: {
      objectID: 'myID2',
      firstname: 'Max',
      lastname: 'Barninger'
    }
  },
  {
    action: 'partialUpdateObject',
    indexName: 'index1',
    body: {
      objectID: 'myID3',
      lastname: 'McFarway'
    }
  },
  {
    action: 'partialUpdateObjectNoCreate',
    indexName: 'index1',
    body: {
      objectID: 'myID4',
      firstname: 'Warren'
    }
  },
  {
    action: 'deleteObject',
    indexName: 'index2',
    body: {
      objectID: 'myID5'
    }
  }
]).then(({ objectIDs }) => {
  console.log(objectIDs);
});

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
client.multiple_batch([
    {
        'action': 'addObject',
        'indexName': 'index1',
        'body': {
            'firstname': 'Jimmie',
            'lastname': 'Barninger'
        }
    },
    {
        'action': 'updateObject',
        'indexName': 'index1',
        'body': {
            'objectID': 'myID2',
            'firstname': 'Max',
            'lastname': 'Barninger'
        }
    },
    {
        'action': 'partialUpdateObject',
        'indexName': 'index1',
        'body': {
            'objectID': 'myID3',
            'lastname': 'McFarway'
        }
    },
    {
        'action': 'partialUpdateObjectNoCreate',
        'indexName': 'index1',
        'body': {
            'objectID': 'myID4',
            'firstname': 'Warren'
        }
    },
    {
        'action': 'deleteObject',
        'indexName': 'index2',
        'body': {
            'objectID': 'myID5'
        }
    }
])

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

let operations: [(IndexName, BatchOperation)] = [
  ("index1", .add(Contact(objectID: "myID1", firstname: "Jimmie", lastname: "Barninger"))),
  ("index1", .update(objectID: "myID2", Contact(objectID: "myID2", firstname: "Max", lastname: "Barninger"))),
  ("index1", .partialUpdate(objectID: "myID3", ["lastname": "McFarway"] as JSON, createIfNotExists: true)),
  ("index1", .partialUpdate(objectID: "myID4", ["firstname": "Warren"] as JSON, createIfNotExists: false)),
  ("index2", .delete(objectID: "myID5"))
]

client.multipleBatchObjects(operations: operations) { 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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
List<JSONObject> array = new ArrayList<>();
array.add(new JSONObject()
  .put("action", "addObject")
  .put("indexName", "index1")
  .put("body", new JSONObject()
    .put("firstname", "Jimmie")
    .put("lastname", "Barninger")
  )
);

array.add(new JSONObject()
  .put("action", "updateObject")
  .put("indexName", "index1")
  .put("body", new JSONObject()
    .put("objectID", "myID2")
    .put("firstname", "Max")
    .put("lastname", "Barninger")
  )
);

array.add(new JSONObject()
  .put("action", "partialUpdateObject")
  .put("indexName", "index1")
  .put("body", new JSONObject()
    .put("objectID", "myID3")
    .put("lastname", "McFarway")
  )
);

array.add(new JSONObject()
  .put("action", "partialUpdateObjectNoCreate")
  .put("indexName", "index1")
  .put("body", new JSONObject()
    .put("objectID", "myID4")
    .put("firstname", "Warren")
  )
);

array.add(new JSONObject()
  .put("action", "deleteObject")
  .put("indexName", "index2")
  .put("body", new JSONObject()
    .put("objectID", "myID5")
  )
);

client.batchAsync(new JSONArray(array), null);

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
List<BatchOperation<Contact>> operations = new List<BatchOperation<Contact>>
  {
      new BatchOperation<Contact>
      {
        Action = BatchActionType.AddObject,
        IndexName = "index1",
        Body = new Contact { FirstName = "Jimmie", LastName = "Barninger" }
      },
      new BatchOperation<Contact>
      {
        Action = BatchActionType.UpdateObject,
        IndexName = "index1",
        Body = new Contact { ObjectID = "myID2", FirstName = "Max", LastName = "Barninger" }
      },
      new BatchOperation<Contact>
      {
        Action = BatchActionType.PartialUpdateObject,
        IndexName = "index1",
        Body = new Contact { ObjectID = "myID3", LastName = "McFarway" }
      },
      new BatchOperation<Contact>
      {
        Action = BatchActionType.PartialUpdateObjectNoCreate,
        IndexName = "index1",
        Body = new Contact { ObjectID = "myID4", LastName = "Warren" }
      },
      new BatchOperation<Contact>
      {
        Action = BatchActionType.DeleteObject,
        IndexName = "index2",
        Body = new Contact { ObjectID = "myID5" }
      }
  };

client.MultipleBatch(operations);

// Asynchronous
client.MultipleBatchAsync(operations);

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
List<BatchOperation<Contact>> operations =
Arrays.asList(
    new BatchOperation<>(
        "index1", ActionEnum.ADD_OBJECT, 
        new Contact()
        .setFirstName("Jimmie")
        .setLastName("Barninger")),
    new BatchOperation<>(
        "index1", ActionEnum.UPDATE_OBJECT,
         new Contact()
         .setObjectID("myID2")
         .setFirstName("Max")
         .setLastName("Barninger")),
    new BatchOperation<>(
        "index1", ActionEnum.PARTIAL_UPDATE_OBJECT, 
        new Contact()
        .setObjectID("myID3")
        .setLastName("McFarway")),
    new BatchOperation<>(
        "index1", ActionEnum.PARTIAL_UPDATE_OBJECT_NO_CREATE, 
        new Contact()
        .setObjectID("myID4")
        .setFirstName("Warren")),
    new BatchOperation<>(
        "index2", ActionEnum.DELETE_OBJECT, 
        new Contact()
        .setObjectID("myID5")));

// Async version
client.multipleBatchAsync(operations);

// Async version
client.multipleBatchAsync(operations);

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
type Contact struct {
    ObjectID  string `json:"objectID,omitempty"`
    Firstname string `json:"firstname,omitempty"`
    Lastname  string `json:"lastname,omitempty"`
}

operations := []search.BatchOperationIndexed{
    {
        IndexName: "index1",
        BatchOperation: search.BatchOperation{
            Action: search.AddObject,
            Body:   Contact{Firstname: "Jimmie", Lastname: "Barninger"},
        },
    },
    {
        IndexName: "index1",
        BatchOperation: search.BatchOperation{
            Action: search.UpdateObject,
            Body:   Contact{ObjectID: "myID2", Firstname: "Max", Lastname: "Barninger"},
        },
    },
    {
        IndexName: "index1",
        BatchOperation: search.BatchOperation{
            Action: search.PartialUpdateObject,
            Body:   Contact{ObjectID: "myID3", Lastname: "McFarway"},
        },
    },
    {
        IndexName: "index1",
        BatchOperation: search.BatchOperation{
            Action: search.PartialUpdateObjectNoCreate,
            Body:   Contact{ObjectID: "myID4", Firstname: "Warren"},
        },
    },
    {
        IndexName: "index2",
        BatchOperation: search.BatchOperation{
            Action: search.DeleteObject,
            Body:   Contact{ObjectID: "myID5"},
        },
    },
}

res, err := client.MultipleBatch(operations)

1
2
3
4
5
6
7
8
9
client.execute {
  batch(
    index into "index1" `object` Contact("", "Jimmie", "Barninger"),
    index into "index1" `object` ContactWithObjectID("myID2", "Max", "Barninger"),
    partialUpdate from "index1" `object` ContactWithObjectID("myID3", "", "McFarway"),
    partialUpdate from "index1" `object` ContactWithObjectID("myID4", "Warren", "") createIfNotExists false,
    delete from "index2" objectId "myID5"
  )
}

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
49
50
51
52
@Serializable
data class Contact(
    val firstname: String,
    val lastname: String,
    override val objectID: ObjectID
) : Indexable

val operations = listOf(
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.AddObject(
            json {
                "firstname" to "Jimmie"
                "lastname" to "Barninger"
            }
        )
    ),
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.AddObject.from(
            serializer = Contact.serializer(),
            data = Contact("Jimmie", "Barninger", ObjectID("myID1"))
        )
    ),
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.PartialUpdateObject.from(
            serializer = Contact.serializer(),
            data = Contact("Max", "Barninger", ObjectID("myID2"))
        )
    ),
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.PartialUpdateObject.from(
            objectID = ObjectID("myID3"),
            partial = Partial.Update(Attribute("firstname"), "McFarway")
        )
    ),
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.PartialUpdateObject.from(
            objectID = ObjectID("myID4"),
            partial = Partial.Update(Attribute("firstname"), "Warren"),
            createIfNotExists = false
        )
    ),
    BatchOperationIndex(
        indexName = indexName2,
        operation = BatchOperation.DeleteObject(ObjectID("myID5"))
    )
)
client.multipleBatchObjects(operations)

Batch write operations and send extra HTTP headers

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
$operations = [
  [
    'action' => 'addObject',
    'indexName' => 'index1',
    'body' => [
      'firstname' => 'Jimmie',
      'lastname' => 'Barninger'
    ]
  ],
  [
    'action' => 'addObject',
    'indexName' => 'index2',
    'body' => [
      'firstname' => 'Warren',
      'lastname' => 'Speach'
    ]
  ]
];

$res = $client->multipleBatch($operations, [
  'X-Forwarded-For' => '94.228.178.246'
]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
operations = [
 {
   'action': 'addObject',
   'indexName': 'index1',
   'body': {'firstname': 'Jimmie', 'lastname': 'Barninger'}
 },
 {
   'action': 'addObject',
   'indexName': 'index2',
   'body': {'firstname': 'Warren', 'lastname': 'Speach'}
 }
]

res = client.batch(operations, {
  headers: {
    'X-Forwarded-For': '94.228.178.246'
  }
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
client.multipleBatch([
    {
      action: 'addObject',
      indexName: 'index1',
      body: { firstname: 'Jimmie', lastname: 'Barninger' }
    },
    {
      action: 'addObject',
      indexName: 'index2',
      body: { firstname: 'Warren', lastname: 'Speach' }
    }
  ], {
    headers: {
      'X-Forwarded-For': '94.228.178.246'
    }
  }).then(({ objectIDs }) => {
    console.log(objectIDs);
  });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
operations = [
    {
        'action': 'addObject',
        'indexName': 'index1',
        'body': {'firstname': 'Jimmie', 'lastname': 'Barninger'}
    },
    {
        'action': 'addObject',
        'indexName': 'index2',
        'body': {'firstname': 'Warren', 'lastname': 'Speach'}
    }
]

res = client.multiple_batch(operations, {
    'X-Forwarded-For': '94.228.178.246'
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
var requestOptions = RequestOptions()
requestOptions.headers["X-Algolia-User-ID"] = "user123"

struct Contact: Codable {
  let objectID: ObjectID
  let firstname: String
  let lastname: String
}

let operations: [(IndexName, BatchOperation)] = [
  ("index1", .add(Contact(objectID: "myID1", firstname: "Jimmie", lastname: "Barninger"))),
  ("index2", .add(Contact(objectID: "myID2", firstname: "Warren", lastname: "Speach")))
]

client.multipleBatchObjects(operations: operations, requestOptions: requestOptions) { 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
25
List<JSONObject> array = new ArrayList<>();

array.add(new JSONObject()
  .put("action", "addObject")
  .put("indexName", "index1")
  .put("body", new JSONObject()
    .put("firstname", "Jimmie")
    .put("lastname", "Barninger")
  )
);

array.add(new JSONObject()
  .put("action", "addObject")
  .put("indexName", "index2")
  .put("body", new JSONObject()
      .put("firstname", "Warren")
      .put("lastname", "Speach")
  )
);

client.batchAsync(
  new JSONArray(array),
  new RequestOptions().setHeader("X-Algolia-User-ID", "94.228.178.246"),
  null
);

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
RequestOptions requestOptions = new RequestOptions
{
    Headers = new Dictionary<string,string>{ { "X-Algolia-User-ID", "user123" } }
};

  List<BatchOperation<Contact>> operations = new List<BatchOperation<Contact>>
  {
      new BatchOperation<Contact>
      {
        Action = BatchActionType.AddObject,
        IndexName = "index1",
        Body = new Contact { FirstName = "Jimmie", LastName = "Barninger" }
      },
      new BatchOperation<Contact>
      {
        Action = BatchActionType.AddObject,
        IndexName = "index1",
        Body = new Contact { FirstName = "Warren", LastName = "Speach" }
      }
  };

client.MultipleBatch(operations, requestOptions);

// Asynchronous
client.MultipleBatchAsync(operations, requestOptions);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
List<BatchOperation<Contact>> operations =
Arrays.asList(
    new BatchOperation<>(
        "index1", ActionEnum.ADD_OBJECT, 
        new Contact()
        .setFirstName("Jimmie")
        .setLastName("Barninger")),
    new BatchOperation<>(
        "index2", ActionEnum.ADD_OBJECT, 
        new Contact()
        .setFirstName("Warren")
        .setLastName("Speach")));

// Async version
client.multipleBatchAsync(operations, 
  new RequestOptions().addExtraHeader("X-Algolia-User-ID", "user123"));

// Async version
client.multipleBatchAsync(operations, 
  new RequestOptions().addExtraHeader("X-Algolia-User-ID", "user123"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
contact := Contact{
    Firstname: "Jimmie",
    Lastname:  "Barninger",
}

operation := search.BatchOperation{Action: search.AddObject, Body: contact}

operations := []search.BatchOperationIndexed{
    {IndexName: "prodIndex", BatchOperation: operation},
    {IndexName: "devIndex", BatchOperation: operation},
}

res, err := client.MultipleBatch(
    operations,
    opt.ExtraHeaders(map[string]string{"X-Algolia-User-ID": "userID2"}),
)

1
2
3
4
5
6
7
8
client.execute {
  batch(
    index into "index1" `object` Contact("Jimmie", "Barninger"),
    index into "index2" `object` Contact("Warren", "Speach")
  ) options RequestOptions(extraHeaders = Some(
    Map("X-Algolia-User-ID" => "user123"))
  )
}

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
49
50
51
52
53
54
55
56
@Serializable
data class Contact(
    val firstname: String,
    val lastname: String,
    override val objectID: ObjectID
) : Indexable

val operations = listOf(
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.AddObject(
            json {
                "firstname" to "Jimmie"
                "lastname" to "Barninger"
            }
        )
    ),
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.AddObject.from(
            serializer = Contact.serializer(),
            data = Contact("Jimmie", "Barninger", ObjectID("myID1"))
        )
    ),
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.PartialUpdateObject.from(
            serializer = Contact.serializer(),
            data = Contact("Max", "Barninger", ObjectID("myID2"))
        )
    ),
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.PartialUpdateObject.from(
            objectID = ObjectID("myID3"),
            partial = Partial.Update(Attribute("firstname"), "McFarway")
        )
    ),
    BatchOperationIndex(
        indexName = indexName1,
        operation = BatchOperation.PartialUpdateObject.from(
            objectID = ObjectID("myID4"),
            partial = Partial.Update(Attribute("firstname"), "Warren"),
            createIfNotExists = false
        )
    ),
    BatchOperationIndex(
        indexName = indexName2,
        operation = BatchOperation.DeleteObject(ObjectID("myID5"))
    )
)
val requestOptions = requestOptions {
    headerAlgoliaUserId(UserID("user123"))
}

client.multipleBatchObjects(operations, requestOptions)

Parameters


            operations

type: list of

Required

List of operation.

Each operation is described by:

action: type of operation
indexName: name of the index targeted by this operation
body: arguments to the operation (depends on the type of the operation)


            requestOptions

type: key/value mapping

default: No requestOptions

Optional

A mapping of requestOptions to send along with the query.

operations ➔ operation


            action

type: string

Required

Actions that need to be performed. It can be one of the following values:

addObject: Add an object.
updateObject: Add or replace an existing object. You must set the objectID attribute to indicate the object to update.
partialUpdateObject: Partially update an object. You must set the objectID attribute to indicate the object to update.
partialUpdateObjectNoCreate: Same as partialUpdateObject, except that the object is not created if the object designated by objectID does not exist.
deleteObject: Delete an object. You must set the objectID attribute to indicate the object to delete.


            indexName

type: string

Required

Index name to target.


            body

type: object

Required

The JSON object containing the information you need for the selected action.

For example, deleteObject would be: An object with the following format

Copy

1
2
3
{
  "objectID": "myID1"
}

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
{
  "objectIDs": [
    "myObjectID1",
    "myObjectID2"
  ],
  "taskID": {
    "index1": 29866710291
  }
}

`objectIDs`	list List of objectIDs affected by the batch of operations.
`taskID`	list A list of taskIDs to use with the waitTask method. One for each index.

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

Custom Batch

About this method

Examples

Batch write operations

Batch write operations and send extra HTTP headers

Parameters

operations ➔ operation

Response

JSON format

Did you find this page helpful?

On this page