curl --request POST \
  --url https://algolia_application_id.algolia.net/1/indexes/ALGOLIA_INDEX_NAME/batch \
  --header 'accept: application/json' \
  --header 'content-type: application/json' \
  --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
  --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID' \
  --data '
{
  "requests": [
    {
      "action": "addObject",
      "body": {
        "name": "Betty Jane McCamey",
        "company": "Vita Foods Inc.",
        "email": "betty@mccamey.com"
      }
    },
    {
      "action": "addObject",
      "body": {
        "name": "Gayla geimer",
        "company": "Ortman McCain Co.",
        "email": "gayla@geimer.com"
      }
    }
  ]
}
'

// Initialize the client
var client = new SearchClient(new SearchConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY"));

// Call the API
var response = await client.BatchAsync(
  "<YOUR_INDEX_NAME>",
  new BatchWriteParams
  {
    Requests = new List<BatchRequest>
    {
      new BatchRequest
      {
        Action = Enum.Parse<Action>("AddObject"),
        Body = new Dictionary<string, string> { { "key", "bar" }, { "foo", "1" } },
      },
      new BatchRequest
      {
        Action = Enum.Parse<Action>("AddObject"),
        Body = new Dictionary<string, string> { { "key", "baz" }, { "foo", "2" } },
      },
    },
  }
);

// print the response
Console.WriteLine(response);

// Initialize the client
final client =
    SearchClient(appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

// Call the API
final response = await client.batch(
  indexName: "<YOUR_INDEX_NAME>",
  batchWriteParams: BatchWriteParams(
    requests: [
      BatchRequest(
        action: Action.fromJson("addObject"),
        body: {
          'key': "bar",
          'foo': "1",
        },
      ),
      BatchRequest(
        action: Action.fromJson("addObject"),
        body: {
          'key': "baz",
          'foo': "2",
        },
      ),
    ],
  ),
);

// print the response
print(response);

// Initialize the client
client, err := search.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
if err != nil {
  // The client can fail to initialize if you pass an invalid parameter.
  panic(err)
}

// Call the API
response, err := client.Batch(client.NewApiBatchRequest(
  "<YOUR_INDEX_NAME>",
  search.NewEmptyBatchWriteParams().SetRequests(
    []search.BatchRequest{
      *search.NewEmptyBatchRequest().SetAction(search.Action("addObject")).SetBody(map[string]any{"key": "bar", "foo": "1"}),
      *search.NewEmptyBatchRequest().SetAction(search.Action("addObject")).SetBody(map[string]any{"key": "baz", "foo": "2"}),
    }),
))
if err != nil {
  // handle the eventual error
  panic(err)
}


// print the response
print(response)

// Initialize the client
SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

// Call the API
BatchResponse response = client.batch(
  "<YOUR_INDEX_NAME>",
  new BatchWriteParams().setRequests(
    Arrays.asList(
      new BatchRequest().setAction(Action.ADD_OBJECT).setBody(
        new HashMap() {
          {
            put("key", "bar");
            put("foo", "1");
          }
        }
      ),
      new BatchRequest().setAction(Action.ADD_OBJECT).setBody(
        new HashMap() {
          {
            put("key", "baz");
            put("foo", "2");
          }
        }
      )
    )
  )
);

// print the response
System.out.println(response);

// Initialize the client
const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// Call the API
const response = await client.batch({
  indexName: '<YOUR_INDEX_NAME>',
  batchWriteParams: {
    requests: [
      { action: 'addObject', body: { key: 'bar', foo: '1' } },
      { action: 'addObject', body: { key: 'baz', foo: '2' } },
    ],
  },
});


// print the response
console.log(response);

// Initialize the client
val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

// Call the API
var response =
  client.batch(
    indexName = "<YOUR_INDEX_NAME>",
    batchWriteParams =
      BatchWriteParams(
        requests =
          listOf(
            BatchRequest(
              action = Action.entries.first { it.value == "addObject" },
              body =
                buildJsonObject {
                  put("key", JsonPrimitive("bar"))
                  put("foo", JsonPrimitive("1"))
                },
            ),
            BatchRequest(
              action = Action.entries.first { it.value == "addObject" },
              body =
                buildJsonObject {
                  put("key", JsonPrimitive("baz"))
                  put("foo", JsonPrimitive("2"))
                },
            ),
          )
      ),
  )


// print the response
println(response)

// Initialize the client
$client = SearchClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// Call the API
$response = $client->batch(
    '<YOUR_INDEX_NAME>',
    ['requests' => [
        ['action' => 'addObject',
            'body' => ['key' => 'bar',
                'foo' => '1',
            ],
        ],

        ['action' => 'addObject',
            'body' => ['key' => 'baz',
                'foo' => '2',
            ],
        ],
    ],
    ],
);


// print the response
var_dump($response);

# Initialize the client
# In an asynchronous context, you can use SearchClient instead, which exposes the exact same methods.
client = SearchClientSync("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Call the API
response = client.batch(
    index_name="<YOUR_INDEX_NAME>",
    batch_write_params={
        "requests": [
            {
                "action": "addObject",
                "body": {
                    "key": "bar",
                    "foo": "1",
                },
            },
            {
                "action": "addObject",
                "body": {
                    "key": "baz",
                    "foo": "2",
                },
            },
        ],
    },
)


# print the response
print(response)

# Initialize the client
client = Algolia::SearchClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Call the API
response = client.batch(
  "<YOUR_INDEX_NAME>",
  Algolia::Search::BatchWriteParams.new(
    requests: [
      Algolia::Search::BatchRequest.new(action: "addObject", body: {key: "bar", foo: "1"}),
      Algolia::Search::BatchRequest.new(action: "addObject", body: {key: "baz", foo: "2"})
    ]
  )
)


# print the response
puts(response)

// Initialize the client
val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

// Call the API
val response = Await.result(
  client.batch(
    indexName = "<YOUR_INDEX_NAME>",
    batchWriteParams = BatchWriteParams(
      requests = Seq(
        BatchRequest(
          action = Action.withName("addObject"),
          body = JObject(List(JField("key", JString("bar")), JField("foo", JString("1"))))
        ),
        BatchRequest(
          action = Action.withName("addObject"),
          body = JObject(List(JField("key", JString("baz")), JField("foo", JString("2"))))
        )
      )
    )
  ),
  Duration(100, "sec")
)

// print the response
println(response)

// Initialize the client
let client = try SearchClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")

// Call the API
let response = try await client.batch(
    indexName: "<YOUR_INDEX_NAME>",
    batchWriteParams: SearchBatchWriteParams(requests: [
        SearchBatchRequest(action: SearchAction.addObject, body: ["key": "bar", "foo": "1"]),
        SearchBatchRequest(action: SearchAction.addObject, body: ["key": "baz", "foo": "2"]),
    ])
)

// print the response
print(response)

{
  "objectIDs": [
    "record-1",
    "record-2"
  ],
  "taskID": 1514562690001
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}