Guides / Sending and managing data / Send and update your data / Connectors

Sep 25, 2025

Push to Algolia

Get started

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Data sources.
On the Connectors page, select Push to Algolia, then click Connect.
Configure your transformation: create a new one or reuse an existing one.
Configure your destination: create a new one or reuse an existing one.
Create the task to generate a taskID.
See the usage section below to update your API client implementation.

Usage

Search API client’s `WithTransformation` helper methods

The helper methods are designed to be drop-in replacements of the standard API clients methods (saveObjects, partialUpdateObjects, replaceAllObjects) but all relies on the push API endpoints and are subject to the Connectors Limits.

This solution is recommended if:

You only have one destination linked to the index you are targeting.
You already have an existing implementation using the Search API client.

`saveObjectsWithTransformation`

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import "github.com/algolia/algoliasearch-client-go/v4/algolia/search"

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

response, err := client.SaveObjectsWithTransformation(
  "ALGOLIA_INDEX_NAME",
  []map[string]any{map[string]any{"objectID": "1", "name": "Adam"}, map[string]any{"objectID": "2", "name": "Benoit"}}, search.WithWaitForTasks(true))
if err != nil {
  // handle the eventual error
  panic(err)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import com.algolia.api.SearchClient;
import com.algolia.config.*;

SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

client.saveObjectsWithTransformation(
  "ALGOLIA_INDEX_NAME",
  Arrays.asList(
    new HashMap() {
      {
        put("objectID", "1");
        put("name", "Adam");
      }
    },
    new HashMap() {
      {
        put("objectID", "2");
        put("name", "Benoit");
      }
    }
  ),
  true
);

1
2
3
4
5
6
7
8
9
10
11
12
import { algoliasearch } from 'algoliasearch';

const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

const response = await client.saveObjectsWithTransformation({
  indexName: 'cts_e2e_saveObjectsWithTransformation_javascript',
  objects: [
    { objectID: '1', name: 'Adam' },
    { objectID: '2', name: 'Benoit' },
  ],
  waitForTasks: true,
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
use Algolia\AlgoliaSearch\Api\SearchClient;

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

$response = $client->saveObjectsWithTransformation(
    'ALGOLIA_INDEX_NAME',
    [
        ['objectID' => '1',
            'name' => 'Adam',
        ],

        ['objectID' => '2',
            'name' => 'Benoit',
        ],
    ],
    true,
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from algoliasearch.search.client import SearchClientSync
from json import loads

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

response = client.save_objects_with_transformation(
    index_name="ALGOLIA_INDEX_NAME",
    objects=[
        {
            "objectID": "1",
            "name": "Adam",
        },
        {
            "objectID": "2",
            "name": "Benoit",
        },
    ],
    wait_for_tasks=True,
)

`partialUpdateObjectsWithTransformation`

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import "github.com/algolia/algoliasearch-client-go/v4/algolia/search"

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

response, err := client.PartialUpdateObjectsWithTransformation(
  "ALGOLIA_INDEX_NAME",
  []map[string]any{map[string]any{"objectID": "1", "name": "Adam"}, map[string]any{"objectID": "2", "name": "Benoit"}}, search.WithCreateIfNotExists(true), search.WithWaitForTasks(true))
if err != nil {
  // handle the eventual error
  panic(err)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import com.algolia.api.SearchClient;
import com.algolia.config.*;

SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

client.partialUpdateObjectsWithTransformation(
  "ALGOLIA_INDEX_NAME",
  Arrays.asList(
    new HashMap() {
      {
        put("objectID", "1");
        put("name", "Adam");
      }
    },
    new HashMap() {
      {
        put("objectID", "2");
        put("name", "Benoit");
      }
    }
  ),
  true,
  true
);

1
2
3
4
5
6
7
8
9
10
11
12
13
import { algoliasearch } from 'algoliasearch';

const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

const response = await client.partialUpdateObjectsWithTransformation({
  indexName: 'cts_e2e_partialUpdateObjectsWithTransformation_javascript',
  objects: [
    { objectID: '1', name: 'Adam' },
    { objectID: '2', name: 'Benoit' },
  ],
  createIfNotExists: true,
  waitForTasks: true,
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
use Algolia\AlgoliaSearch\Api\SearchClient;

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

$response = $client->partialUpdateObjectsWithTransformation(
    'ALGOLIA_INDEX_NAME',
    [
        ['objectID' => '1',
            'name' => 'Adam',
        ],

        ['objectID' => '2',
            'name' => 'Benoit',
        ],
    ],
    true,
    true,
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from algoliasearch.search.client import SearchClientSync
from json import loads

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

response = client.partial_update_objects_with_transformation(
    index_name="ALGOLIA_INDEX_NAME",
    objects=[
        {
            "objectID": "1",
            "name": "Adam",
        },
        {
            "objectID": "2",
            "name": "Benoit",
        },
    ],
    create_if_not_exists=True,
    wait_for_tasks=True,
)

`replaceAllObjectsWithTransformation`

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import "github.com/algolia/algoliasearch-client-go/v4/algolia/search"

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

response, err := client.ReplaceAllObjectsWithTransformation(
  "ALGOLIA_INDEX_NAME",
  []map[string]any{map[string]any{"objectID": "1", "name": "Adam"}, map[string]any{"objectID": "2", "name": "Benoit"}, map[string]any{"objectID": "3", "name": "Cyril"}, map[string]any{"objectID": "4", "name": "David"}, map[string]any{"objectID": "5", "name": "Eva"}, map[string]any{"objectID": "6", "name": "Fiona"}, map[string]any{"objectID": "7", "name": "Gael"}, map[string]any{"objectID": "8", "name": "Hugo"}, map[string]any{"objectID": "9", "name": "Igor"}, map[string]any{"objectID": "10", "name": "Julia"}}, search.WithBatchSize(3))
if err != nil {
  // handle the eventual error
  panic(err)
}

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import com.algolia.api.SearchClient;
import com.algolia.config.*;

SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

client.replaceAllObjectsWithTransformation(
  "ALGOLIA_INDEX_NAME",
  Arrays.asList(
    new HashMap() {
      {
        put("objectID", "1");
        put("name", "Adam");
      }
    },
    new HashMap() {
      {
        put("objectID", "2");
        put("name", "Benoit");
      }
    },
    new HashMap() {
      {
        put("objectID", "3");
        put("name", "Cyril");
      }
    },
    new HashMap() {
      {
        put("objectID", "4");
        put("name", "David");
      }
    },
    new HashMap() {
      {
        put("objectID", "5");
        put("name", "Eva");
      }
    },
    new HashMap() {
      {
        put("objectID", "6");
        put("name", "Fiona");
      }
    },
    new HashMap() {
      {
        put("objectID", "7");
        put("name", "Gael");
      }
    },
    new HashMap() {
      {
        put("objectID", "8");
        put("name", "Hugo");
      }
    },
    new HashMap() {
      {
        put("objectID", "9");
        put("name", "Igor");
      }
    },
    new HashMap() {
      {
        put("objectID", "10");
        put("name", "Julia");
      }
    }
  ),
  3
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import { algoliasearch } from 'algoliasearch';

const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

const response = await client.replaceAllObjectsWithTransformation({
  indexName: 'cts_e2e_replace_all_objects_with_transformation_javascript',
  objects: [
    { objectID: '1', name: 'Adam' },
    { objectID: '2', name: 'Benoit' },
    { objectID: '3', name: 'Cyril' },
    { objectID: '4', name: 'David' },
    { objectID: '5', name: 'Eva' },
    { objectID: '6', name: 'Fiona' },
    { objectID: '7', name: 'Gael' },
    { objectID: '8', name: 'Hugo' },
    { objectID: '9', name: 'Igor' },
    { objectID: '10', name: 'Julia' },
  ],
  batchSize: 3,
});

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
use Algolia\AlgoliaSearch\Api\SearchClient;

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

$response = $client->replaceAllObjectsWithTransformation(
    'ALGOLIA_INDEX_NAME',
    [
        ['objectID' => '1',
            'name' => 'Adam',
        ],

        ['objectID' => '2',
            'name' => 'Benoit',
        ],

        ['objectID' => '3',
            'name' => 'Cyril',
        ],

        ['objectID' => '4',
            'name' => 'David',
        ],

        ['objectID' => '5',
            'name' => 'Eva',
        ],

        ['objectID' => '6',
            'name' => 'Fiona',
        ],

        ['objectID' => '7',
            'name' => 'Gael',
        ],

        ['objectID' => '8',
            'name' => 'Hugo',
        ],

        ['objectID' => '9',
            'name' => 'Igor',
        ],

        ['objectID' => '10',
            'name' => 'Julia',
        ],
    ],
    3,
);

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
from algoliasearch.search.client import SearchClientSync
from json import loads

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

response = client.replace_all_objects_with_transformation(
    index_name="ALGOLIA_INDEX_NAME",
    objects=[
        {
            "objectID": "1",
            "name": "Adam",
        },
        {
            "objectID": "2",
            "name": "Benoit",
        },
        {
            "objectID": "3",
            "name": "Cyril",
        },
        {
            "objectID": "4",
            "name": "David",
        },
        {
            "objectID": "5",
            "name": "Eva",
        },
        {
            "objectID": "6",
            "name": "Fiona",
        },
        {
            "objectID": "7",
            "name": "Gael",
        },
        {
            "objectID": "8",
            "name": "Hugo",
        },
        {
            "objectID": "9",
            "name": "Igor",
        },
        {
            "objectID": "10",
            "name": "Julia",
        },
    ],
    batch_size=3,
)

Ingestion API client’s `push` method

This solution is recommended if you only have one destination linked to the index you are targeting.

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
using Algolia.Search.Clients;
using Algolia.Search.Http;
using Algolia.Search.Models.Ingestion;

var client = new IngestionClient(
  new IngestionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")
);

var response = await client.PushAsync(
  "ALGOLIA_INDEX_NAME",
  new PushTaskPayload
  {
    Action = Enum.Parse<Action>("AddObject"),
    Records = new List<PushTaskRecords>
    {
      new PushTaskRecords
      {
        ObjectID = "o",
        AdditionalProperties = new Dictionary<string, object>
        {
          { "key", "bar" },
          { "foo", "1" },
        },
      },
      new PushTaskRecords
      {
        ObjectID = "k",
        AdditionalProperties = new Dictionary<string, object>
        {
          { "key", "baz" },
          { "foo", "2" },
        },
      },
    },
  }
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import "github.com/algolia/algoliasearch-client-go/v4/algolia/ingestion"

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

response, err := client.Push(client.NewApiPushRequest(
  "ALGOLIA_INDEX_NAME",
  ingestion.NewEmptyPushTaskPayload().SetAction(ingestion.Action("addObject")).SetRecords(
    []ingestion.PushTaskRecords{*ingestion.NewEmptyPushTaskRecords().SetAdditionalProperty("key", "bar").SetAdditionalProperty("foo", "1").SetObjectID("o"), *ingestion.NewEmptyPushTaskRecords().SetAdditionalProperty("key", "baz").SetAdditionalProperty("foo", "2").SetObjectID("k")})))
if err != nil {
  // handle the eventual error
  panic(err)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import com.algolia.api.IngestionClient;
import com.algolia.config.*;

IngestionClient client = new IngestionClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION");

client.push(
  "ALGOLIA_INDEX_NAME",
  new PushTaskPayload()
    .setAction(Action.ADD_OBJECT)
    .setRecords(
      Arrays.asList(
        new PushTaskRecords().setAdditionalProperty("key", "bar").setAdditionalProperty("foo", "1").setObjectID("o"),
        new PushTaskRecords().setAdditionalProperty("key", "baz").setAdditionalProperty("foo", "2").setObjectID("k")
      )
    )
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import { algoliasearch } from 'algoliasearch';

// Replace 'us' with your Algolia Application Region
const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY').initIngestion({ region: 'us' });

const response = await client.push({
  indexName: 'foo',
  pushTaskPayload: {
    action: 'addObject',
    records: [
      { key: 'bar', foo: '1', objectID: 'o' },
      { key: 'baz', foo: '2', objectID: 'k' },
    ],
  },
});

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
import com.algolia.client.api.IngestionClient
import com.algolia.client.configuration.*
import com.algolia.client.transport.*

val client = IngestionClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY", region = "ALGOLIA_APPLICATION_REGION")

var response = client.push(
  indexName = "ALGOLIA_INDEX_NAME",
  pushTaskPayload = PushTaskPayload(
    action = Action.entries.first { it.value == "addObject" },
    records = listOf(
      PushTaskRecords(
        objectID = "o",
        additionalProperties = mapOf(
          "key" to JsonPrimitive("bar"),
          "foo" to JsonPrimitive("1"),
        ),
      ),
      PushTaskRecords(
        objectID = "k",
        additionalProperties = mapOf(
          "key" to JsonPrimitive("baz"),
          "foo" to JsonPrimitive("2"),
        ),
      ),
    ),
  ),
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
use Algolia\AlgoliaSearch\Api\IngestionClient;

$client = IngestionClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY', 'ALGOLIA_APPLICATION_REGION');

$response = $client->push(
    'ALGOLIA_INDEX_NAME',
    ['action' => 'addObject',
        'records' => [
            ['key' => 'bar',
                'foo' => '1',
                'objectID' => 'o',
            ],

            ['key' => 'baz',
                'foo' => '2',
                'objectID' => 'k',
            ],
        ],
    ],
);

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
from algoliasearch.ingestion.client import IngestionClientSync
from json import loads

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

response = client.push(
    index_name="ALGOLIA_INDEX_NAME",
    push_task_payload={
        "action": "addObject",
        "records": [
            {
                "key": "bar",
                "foo": "1",
                "objectID": "o",
            },
            {
                "key": "baz",
                "foo": "2",
                "objectID": "k",
            },
        ],
    },
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
require "algolia"

client = Algolia::IngestionClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")

response = client.push(
  "ALGOLIA_INDEX_NAME",
  Algolia::Ingestion::PushTaskPayload.new(
    action: "addObject",
    records: [
      Algolia::Ingestion::PushTaskRecords.new(key: "bar", foo: "1", algolia_object_id: "o"),
      Algolia::Ingestion::PushTaskRecords.new(key: "baz", foo: "2", algolia_object_id: "k")
    ]
  )
)

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
import algoliasearch.api.IngestionClient
import algoliasearch.config.*

val client = IngestionClient(
  appId = "ALGOLIA_APPLICATION_ID",
  apiKey = "ALGOLIA_API_KEY",
  region = "ALGOLIA_APPLICATION_REGION"
)

val response = Await.result(
  client.push(
    indexName = "ALGOLIA_INDEX_NAME",
    pushTaskPayload = PushTaskPayload(
      action = Action.withName("addObject"),
      records = Seq(
        PushTaskRecords(
          objectID = "o",
          additionalProperties = Some(List(JField("key", JString("bar")), JField("foo", JString("1"))))
        ),
        PushTaskRecords(
          objectID = "k",
          additionalProperties = Some(List(JField("key", JString("baz")), JField("foo", JString("2"))))
        )
      )
    )
  ),
  Duration(100, "sec")
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import Ingestion

let client = try IngestionClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY", region: .us)

let response = try await client.push(
    indexName: "ALGOLIA_INDEX_NAME",
    pushTaskPayload: PushTaskPayload(
        action: IngestionAction.addObject,
        records: [
            PushTaskRecords(from: [
                "objectID": AnyCodable("o"),
                "key": AnyCodable("bar"),
                "foo": AnyCodable("1"),
            ]),
            PushTaskRecords(from: [
                "objectID": AnyCodable("k"),
                "key": AnyCodable("baz"),
                "foo": AnyCodable("2"),
            ]),
        ]
    )
)

Ingestion API client’s `pushTask` method

This solution is recommended if you have multiple destinations linked to the index you are targeting.

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
using Algolia.Search.Clients;
using Algolia.Search.Http;
using Algolia.Search.Models.Ingestion;

var client = new IngestionClient(
  new IngestionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")
);

var response = await client.PushTaskAsync(
  "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
  new PushTaskPayload
  {
    Action = Enum.Parse<Action>("AddObject"),
    Records = new List<PushTaskRecords>
    {
      new PushTaskRecords
      {
        ObjectID = "o",
        AdditionalProperties = new Dictionary<string, object>
        {
          { "key", "bar" },
          { "foo", "1" },
        },
      },
      new PushTaskRecords
      {
        ObjectID = "k",
        AdditionalProperties = new Dictionary<string, object>
        {
          { "key", "baz" },
          { "foo", "2" },
        },
      },
    },
  }
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import "github.com/algolia/algoliasearch-client-go/v4/algolia/ingestion"

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

response, err := client.PushTask(client.NewApiPushTaskRequest(
  "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
  ingestion.NewEmptyPushTaskPayload().SetAction(ingestion.Action("addObject")).SetRecords(
    []ingestion.PushTaskRecords{*ingestion.NewEmptyPushTaskRecords().SetAdditionalProperty("key", "bar").SetAdditionalProperty("foo", "1").SetObjectID("o"), *ingestion.NewEmptyPushTaskRecords().SetAdditionalProperty("key", "baz").SetAdditionalProperty("foo", "2").SetObjectID("k")})))
if err != nil {
  // handle the eventual error
  panic(err)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import com.algolia.api.IngestionClient;
import com.algolia.config.*;

IngestionClient client = new IngestionClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION");

client.pushTask(
  "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
  new PushTaskPayload()
    .setAction(Action.ADD_OBJECT)
    .setRecords(
      Arrays.asList(
        new PushTaskRecords().setAdditionalProperty("key", "bar").setAdditionalProperty("foo", "1").setObjectID("o"),
        new PushTaskRecords().setAdditionalProperty("key", "baz").setAdditionalProperty("foo", "2").setObjectID("k")
      )
    )
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import { algoliasearch } from 'algoliasearch';

// Replace 'us' with your Algolia Application Region
const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY').initIngestion({ region: 'us' });

const response = await client.pushTask({
  taskID: '6c02aeb1-775e-418e-870b-1faccd4b2c0f',
  pushTaskPayload: {
    action: 'addObject',
    records: [
      { key: 'bar', foo: '1', objectID: 'o' },
      { key: 'baz', foo: '2', objectID: 'k' },
    ],
  },
});

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
import com.algolia.client.api.IngestionClient
import com.algolia.client.configuration.*
import com.algolia.client.transport.*

val client = IngestionClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY", region = "ALGOLIA_APPLICATION_REGION")

var response = client.pushTask(
  taskID = "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
  pushTaskPayload = PushTaskPayload(
    action = Action.entries.first { it.value == "addObject" },
    records = listOf(
      PushTaskRecords(
        objectID = "o",
        additionalProperties = mapOf(
          "key" to JsonPrimitive("bar"),
          "foo" to JsonPrimitive("1"),
        ),
      ),
      PushTaskRecords(
        objectID = "k",
        additionalProperties = mapOf(
          "key" to JsonPrimitive("baz"),
          "foo" to JsonPrimitive("2"),
        ),
      ),
    ),
  ),
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
use Algolia\AlgoliaSearch\Api\IngestionClient;

$client = IngestionClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY', 'ALGOLIA_APPLICATION_REGION');

$response = $client->pushTask(
    '6c02aeb1-775e-418e-870b-1faccd4b2c0f',
    ['action' => 'addObject',
        'records' => [
            ['key' => 'bar',
                'foo' => '1',
                'objectID' => 'o',
            ],

            ['key' => 'baz',
                'foo' => '2',
                'objectID' => 'k',
            ],
        ],
    ],
);

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
from algoliasearch.ingestion.client import IngestionClientSync
from json import loads

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

response = client.push_task(
    task_id="6c02aeb1-775e-418e-870b-1faccd4b2c0f",
    push_task_payload={
        "action": "addObject",
        "records": [
            {
                "key": "bar",
                "foo": "1",
                "objectID": "o",
            },
            {
                "key": "baz",
                "foo": "2",
                "objectID": "k",
            },
        ],
    },
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
require "algolia"

client = Algolia::IngestionClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")

response = client.push_task(
  "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
  Algolia::Ingestion::PushTaskPayload.new(
    action: "addObject",
    records: [
      Algolia::Ingestion::PushTaskRecords.new(key: "bar", foo: "1", algolia_object_id: "o"),
      Algolia::Ingestion::PushTaskRecords.new(key: "baz", foo: "2", algolia_object_id: "k")
    ]
  )
)

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
import algoliasearch.api.IngestionClient
import algoliasearch.config.*

val client = IngestionClient(
  appId = "ALGOLIA_APPLICATION_ID",
  apiKey = "ALGOLIA_API_KEY",
  region = "ALGOLIA_APPLICATION_REGION"
)

val response = Await.result(
  client.pushTask(
    taskID = "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
    pushTaskPayload = PushTaskPayload(
      action = Action.withName("addObject"),
      records = Seq(
        PushTaskRecords(
          objectID = "o",
          additionalProperties = Some(List(JField("key", JString("bar")), JField("foo", JString("1"))))
        ),
        PushTaskRecords(
          objectID = "k",
          additionalProperties = Some(List(JField("key", JString("baz")), JField("foo", JString("2"))))
        )
      )
    )
  ),
  Duration(100, "sec")
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import Ingestion

let client = try IngestionClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY", region: .us)

let response = try await client.pushTask(
    taskID: "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
    pushTaskPayload: PushTaskPayload(
        action: IngestionAction.addObject,
        records: [
            PushTaskRecords(from: [
                "objectID": AnyCodable("o"),
                "key": AnyCodable("bar"),
                "foo": AnyCodable("1"),
            ]),
            PushTaskRecords(from: [
                "objectID": AnyCodable("k"),
                "key": AnyCodable("baz"),
                "foo": AnyCodable("2"),
            ]),
        ]
    )
)

Performance considerations

If you don’t need an Algolia-managed transformation, send records in the traditional way to avoid unnecessary overhead.

Supported indexing actions

The Push to Algolia connector supports all action types for batch indexing operations. For deleteObject, delete and clear actions, it skips the transformation and uses traditional indexing.

Connector Debugger

To check and debug pushTask operations:

Check incoming events in the Connector Debugger on the Algolia dashboard.
- The eventID returned by a successful pushTask API call shows the status of the indexing operation.
To get real-time feedback, add the watch parameter to the pushTask API call. The response body reports errors and successes.

Limitations

This connector is subject to the following limitations:

Elasticsearch

Supabase

Push to Algolia

On this page

Get started

Usage

Search API client’s `WithTransformation` helper methods

`saveObjectsWithTransformation`

`partialUpdateObjectsWithTransformation`

`replaceAllObjectsWithTransformation`

Ingestion API client’s `push` method

Ingestion API client’s `pushTask` method

Performance considerations

Supported indexing actions

Connector Debugger

Limitations

On this page

Push to Algolia

On this page

Get started

Usage

Search API client’s WithTransformation helper methods

saveObjectsWithTransformation

partialUpdateObjectsWithTransformation

replaceAllObjectsWithTransformation

Ingestion API client’s push method

Ingestion API client’s pushTask method

Performance considerations

Supported indexing actions

Connector Debugger

Limitations

On this page

Search API client’s `WithTransformation` helper methods

`saveObjectsWithTransformation`

`partialUpdateObjectsWithTransformation`

`replaceAllObjectsWithTransformation`

Ingestion API client’s `push` method

Ingestion API client’s `pushTask` method