Skip to main content
POST
/
1
/
indexes
/
{indexName}
/
rules
/
batch
curl
curl --request POST \
  --url 'https://algolia_application_id.algolia.net/1/indexes/ALGOLIA_INDEX_NAME/rules/batch?forwardToReplicas=true&clearExistingRules=true' \
  --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 '
[
  {
    "objectID": "lorem",
    "conditions": [
      {
        "pattern": "{facet:genre}",
        "anchoring": "is",
        "alternatives": false,
        "context": "mobile",
        "filters": "genre:comedy"
      }
    ],
    "consequence": {
      "params": {
        "similarQuery": "comedy drama crime Macy Buscemi",
        "filters": "(category:Book OR category:Ebook) AND _tags:published",
        "facetFilters": [
          [
            "category:Book",
            "category:-Movie"
          ],
          "author:John Doe"
        ],
        "optionalFilters": [
          "category:Book",
          "author:John Doe"
        ],
        "numericFilters": [
          [
            "inStock = 1",
            "deliveryDate < 1441755506"
          ],
          "price < 1000"
        ],
        "tagFilters": [
          [
            "Book",
            "Movie"
          ],
          "SciFi"
        ],
        "sumOrFiltersScores": false,
        "restrictSearchableAttributes": [
          "title",
          "author"
        ],
        "facets": [
          "*"
        ],
        "facetingAfterDistinct": false,
        "page": 0,
        "offset": 42,
        "length": 0,
        "aroundLatLng": "40.71,-74.01",
        "aroundLatLngViaIP": false,
        "aroundRadius": 1,
        "aroundPrecision": 10,
        "minimumAroundRadius": 1,
        "insideBoundingBox": "lorem",
        "insidePolygon": [
          [
            47.3165,
            4.9665,
            47.3424,
            5.0201,
            47.32,
            4.9
          ],
          [
            40.9234,
            2.1185,
            38.643,
            1.9916,
            39.2587,
            2.0104
          ]
        ],
        "naturalLanguages": [],
        "ruleContexts": [
          "mobile"
        ],
        "personalizationImpact": 100,
        "userToken": "test-user-123",
        "getRankingInfo": false,
        "synonyms": true,
        "clickAnalytics": false,
        "analytics": true,
        "analyticsTags": [],
        "percentileComputation": true,
        "enableABTest": true,
        "attributesToRetrieve": [
          "author",
          "title",
          "content"
        ],
        "ranking": [
          "typo",
          "geo",
          "words",
          "filters",
          "proximity",
          "attribute",
          "exact",
          "custom"
        ],
        "relevancyStrictness": 90,
        "attributesToHighlight": [
          "author",
          "title",
          "conten",
          "content"
        ],
        "attributesToSnippet": [
          "content:80",
          "description"
        ],
        "highlightPreTag": "<em>",
        "highlightPostTag": "</em>",
        "snippetEllipsisText": "…",
        "restrictHighlightAndSnippetArrays": false,
        "hitsPerPage": 20,
        "minWordSizefor1Typo": 4,
        "minWordSizefor2Typos": 8,
        "typoTolerance": true,
        "allowTyposOnNumericTokens": true,
        "disableTypoToleranceOnAttributes": [
          "sku"
        ],
        "ignorePlurals": [
          "ca",
          "es"
        ],
        "removeStopWords": [
          "ca",
          "es"
        ],
        "queryLanguages": [
          "es"
        ],
        "decompoundQuery": true,
        "enableRules": true,
        "enablePersonalization": false,
        "queryType": "prefixLast",
        "removeWordsIfNoResults": "firstWords",
        "mode": "keywordSearch",
        "semanticSearch": {
          "eventSources": [
            "lorem"
          ]
        },
        "advancedSyntax": false,
        "optionalWords": "lorem",
        "disableExactOnAttributes": [
          "description"
        ],
        "exactOnSingleWordQuery": "attribute",
        "alternativesAsExact": [
          "ignorePlurals",
          "singleWordSynonym"
        ],
        "advancedSyntaxFeatures": [
          "exactPhrase",
          "excludeWords"
        ],
        "distinct": 1,
        "replaceSynonymsInHighlight": false,
        "minProximity": 1,
        "responseFields": [
          "*"
        ],
        "maxValuesPerFacet": 100,
        "sortFacetValuesBy": "count",
        "attributeCriteriaComputedByMinProximity": false,
        "renderingContent": {
          "facetOrdering": {
            "facets": {
              "order": [
                "lorem"
              ]
            },
            "values": {
              "property1": {
                "order": [
                  "lorem"
                ],
                "sortRemainingBy": "count",
                "hide": [
                  "lorem"
                ]
              },
              "property2": {
                "order": [
                  "lorem"
                ],
                "sortRemainingBy": "count",
                "hide": [
                  "lorem"
                ]
              }
            }
          },
          "redirect": {
            "url": "lorem"
          },
          "widgets": {
            "banners": [
              {
                "image": {
                  "urls": [
                    {
                      "url": "lorem"
                    }
                  ],
                  "title": "lorem"
                },
                "link": {
                  "url": "lorem"
                }
              }
            ]
          }
        },
        "enableReRanking": true,
        "reRankingApplyFilter": [
          []
        ],
        "query": {
          "remove": [
            "lorem"
          ],
          "edits": [
            {
              "type": "remove",
              "delete": "lorem",
              "insert": "lorem"
            }
          ]
        },
        "automaticFacetFilters": [
          {
            "facet": "lorem",
            "score": 1,
            "disjunctive": false
          }
        ],
        "automaticOptionalFacetFilters": [
          {
            "facet": "lorem",
            "score": 1,
            "disjunctive": false
          }
        ]
      },
      "promote": [
        {
          "objectIDs": [
            "test-record-123"
          ],
          "position": 0
        }
      ],
      "filterPromotes": false,
      "hide": [
        {
          "objectID": "test-record-123"
        }
      ],
      "redirect": {
        "indexName": "lorem"
      },
      "userData": {
        "settingID": "f2a7b51e3503acc6a39b3784ffb84300",
        "pluginVersion": "1.6.0"
      }
    },
    "description": "Display a promotional banner",
    "enabled": true,
    "validity": [
      {
        "from": 42,
        "until": 42
      }
    ],
    "tags": [
      "lorem"
    ],
    "scope": "lorem",
    "condition": {
      "pattern": "{facet:genre}",
      "anchoring": "is",
      "alternatives": false,
      "context": "mobile",
      "filters": "genre:comedy"
    }
  }
]
'
// Initialize the client
var client = new SearchClient(new SearchConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY"));

// Call the API
var response = await client.SaveRulesAsync(
  "<YOUR_INDEX_NAME>",
  new List<Rule>
  {
    new Rule
    {
      ObjectID = "a-rule-id",
      Conditions = new List<Condition>
      {
        new Condition { Pattern = "smartphone", Anchoring = Enum.Parse<Anchoring>("Contains") },
      },
      Consequence = new Consequence
      {
        Params = new ConsequenceParams { Filters = "brand:apple" },
      },
    },
    new Rule
    {
      ObjectID = "a-second-rule-id",
      Conditions = new List<Condition>
      {
        new Condition { Pattern = "apple", Anchoring = Enum.Parse<Anchoring>("Contains") },
      },
      Consequence = new Consequence
      {
        Params = new ConsequenceParams { Filters = "brand:samsung" },
      },
    },
  },
  false,
  true
);

// 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.saveRules(
  indexName: "<YOUR_INDEX_NAME>",
  rules: [
    Rule(
      objectID: "a-rule-id",
      conditions: [
        Condition(
          pattern: "smartphone",
          anchoring: Anchoring.fromJson("contains"),
        ),
      ],
      consequence: Consequence(
        params: ConsequenceParams(
          filters: "brand:apple",
        ),
      ),
    ),
    Rule(
      objectID: "a-second-rule-id",
      conditions: [
        Condition(
          pattern: "apple",
          anchoring: Anchoring.fromJson("contains"),
        ),
      ],
      consequence: Consequence(
        params: ConsequenceParams(
          filters: "brand:samsung",
        ),
      ),
    ),
  ],
  forwardToReplicas: false,
  clearExistingRules: true,
);

// 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.SaveRules(client.NewApiSaveRulesRequest(
  "<YOUR_INDEX_NAME>",
  []search.Rule{*search.NewEmptyRule().SetObjectID("a-rule-id").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("smartphone").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetFilters("brand:apple"))), *search.NewEmptyRule().SetObjectID("a-second-rule-id").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("apple").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetFilters("brand:samsung")))}).WithForwardToReplicas(false).WithClearExistingRules(true))
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
UpdatedAtResponse response = client.saveRules(
  "<YOUR_INDEX_NAME>",
  Arrays.asList(
    new Rule()
      .setObjectID("a-rule-id")
      .setConditions(Arrays.asList(new Condition().setPattern("smartphone").setAnchoring(Anchoring.CONTAINS)))
      .setConsequence(new Consequence().setParams(new ConsequenceParams().setFilters("brand:apple"))),
    new Rule()
      .setObjectID("a-second-rule-id")
      .setConditions(Arrays.asList(new Condition().setPattern("apple").setAnchoring(Anchoring.CONTAINS)))
      .setConsequence(new Consequence().setParams(new ConsequenceParams().setFilters("brand:samsung")))
  ),
  false,
  true
);

// 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.saveRules({
  indexName: '<YOUR_INDEX_NAME>',
  rules: [
    {
      objectID: 'a-rule-id',
      conditions: [{ pattern: 'smartphone', anchoring: 'contains' }],
      consequence: { params: { filters: 'brand:apple' } },
    },
    {
      objectID: 'a-second-rule-id',
      conditions: [{ pattern: 'apple', anchoring: 'contains' }],
      consequence: { params: { filters: 'brand:samsung' } },
    },
  ],
  forwardToReplicas: false,
  clearExistingRules: true,
});


// 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.saveRules(
    indexName = "<YOUR_INDEX_NAME>",
    rules =
      listOf(
        Rule(
          objectID = "a-rule-id",
          conditions =
            listOf(
              Condition(
                pattern = "smartphone",
                anchoring = Anchoring.entries.first { it.value == "contains" },
              )
            ),
          consequence = Consequence(params = ConsequenceParams(filters = "brand:apple")),
        ),
        Rule(
          objectID = "a-second-rule-id",
          conditions =
            listOf(
              Condition(
                pattern = "apple",
                anchoring = Anchoring.entries.first { it.value == "contains" },
              )
            ),
          consequence = Consequence(params = ConsequenceParams(filters = "brand:samsung")),
        ),
      ),
    forwardToReplicas = false,
    clearExistingRules = true,
  )


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

// Call the API
$response = $client->saveRules(
    '<YOUR_INDEX_NAME>',
    [
        ['objectID' => 'a-rule-id',
            'conditions' => [
                ['pattern' => 'smartphone',
                    'anchoring' => 'contains',
                ],
            ],
            'consequence' => ['params' => ['filters' => 'brand:apple',
            ],
            ],
        ],

        ['objectID' => 'a-second-rule-id',
            'conditions' => [
                ['pattern' => 'apple',
                    'anchoring' => 'contains',
                ],
            ],
            'consequence' => ['params' => ['filters' => 'brand:samsung',
            ],
            ],
        ],
    ],
    false,
    true,
);


// 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.save_rules(
    index_name="<YOUR_INDEX_NAME>",
    rules=[
        {
            "objectID": "a-rule-id",
            "conditions": [
                {
                    "pattern": "smartphone",
                    "anchoring": "contains",
                },
            ],
            "consequence": {
                "params": {
                    "filters": "brand:apple",
                },
            },
        },
        {
            "objectID": "a-second-rule-id",
            "conditions": [
                {
                    "pattern": "apple",
                    "anchoring": "contains",
                },
            ],
            "consequence": {
                "params": {
                    "filters": "brand:samsung",
                },
            },
        },
    ],
    forward_to_replicas=False,
    clear_existing_rules=True,
)


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

# Call the API
response = client.save_rules(
  "<YOUR_INDEX_NAME>",
  [
    Algolia::Search::Rule.new(
      algolia_object_id: "a-rule-id",
      conditions: [Algolia::Search::Condition.new(pattern: "smartphone", anchoring: "contains")],
      consequence: Algolia::Search::Consequence.new(
        params: Algolia::Search::ConsequenceParams.new(filters: "brand:apple")
      )
    ),
    Algolia::Search::Rule.new(
      algolia_object_id: "a-second-rule-id",
      conditions: [Algolia::Search::Condition.new(pattern: "apple", anchoring: "contains")],
      consequence: Algolia::Search::Consequence.new(
        params: Algolia::Search::ConsequenceParams.new(filters: "brand:samsung")
      )
    )
  ],
  false,
  true
)


# 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.saveRules(
    indexName = "<YOUR_INDEX_NAME>",
    rules = Seq(
      Rule(
        objectID = "a-rule-id",
        conditions = Some(
          Seq(
            Condition(
              pattern = Some("smartphone"),
              anchoring = Some(Anchoring.withName("contains"))
            )
          )
        ),
        consequence = Consequence(
          params = Some(
            ConsequenceParams(
              filters = Some("brand:apple")
            )
          )
        )
      ),
      Rule(
        objectID = "a-second-rule-id",
        conditions = Some(
          Seq(
            Condition(
              pattern = Some("apple"),
              anchoring = Some(Anchoring.withName("contains"))
            )
          )
        ),
        consequence = Consequence(
          params = Some(
            ConsequenceParams(
              filters = Some("brand:samsung")
            )
          )
        )
      )
    ),
    forwardToReplicas = Some(false),
    clearExistingRules = Some(true)
  ),
  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.saveRules(
    indexName: "<YOUR_INDEX_NAME>",
    rules: [
        Rule(objectID: "a-rule-id", conditions: [SearchCondition(
            pattern: "smartphone",
            anchoring: SearchAnchoring.contains
        )], consequence: SearchConsequence(params: SearchConsequenceParams(filters: "brand:apple"))),
        Rule(
            objectID: "a-second-rule-id",
            conditions: [SearchCondition(pattern: "apple", anchoring: SearchAnchoring.contains)],
            consequence: SearchConsequence(params: SearchConsequenceParams(filters: "brand:samsung"))
        ),
    ],
    forwardToReplicas: false,
    clearExistingRules: true
)

// print the response
print(response)
{
  "taskID": 1514562690001,
  "updatedAt": "2023-07-04T12:49:15Z"
}
{
  "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"
}
If a rule with the specified object ID doesn’t exist, Algolia creates a new one. Otherwise, existing rules are replaced. This operation is subject to indexing rate limits. Required ACL: editSettings

Authorizations

​
x-algolia-application-id
string
header
required

Your Algolia application ID.

​
x-algolia-api-key
string
header
required

Your Algolia API key with the necessary permissions to make the request. Permissions are controlled through access control lists (ACL) and access restrictions. The required ACL to make a request is listed in each endpoint's reference.

Path Parameters

​
indexName
string
required

Name of the index on which to perform the operation.

Example:

"ALGOLIA_INDEX_NAME"

Query Parameters

​
clearExistingRules
boolean

Whether existing rules should be deleted before adding this batch.

​
forwardToReplicas
boolean

Whether changes are applied to replica indices.

Body

application/json
​
consequence
object
required

Effect of the rule.

For more information, see Consequences.

​
objectID
string
required

Unique identifier of a rule object.

​
condition
object
deprecated

Legacy field for a single condition. This field is maintained for backward compatibility with older rules but should not be used in new implementations.

​
conditions
object[]

Conditions that trigger a rule.

Some consequences require specific conditions or don't require any condition. For more information, see Conditions.

Maximum array length: 25
​
description
string

Description of the rule's purpose to help you distinguish between different rules.

Example:

"Display a promotional banner"

​
enabled
boolean
default:true

Whether the rule is active.

​
scope
string
​
tags
string[]
​
validity
object[]

Time periods when the rule is active.

Response

OK

Response, taskID, and update timestamp.

​
taskID
integer<int64>
required

Unique identifier of a task.

A successful API response means that a task was added to a queue. It might not run immediately. You can check the task's progress with the task operation and this task ID.

Example:

1514562690001

​
updatedAt
string
required

Date and time when the object was updated, in RFC 3339 format.

Example:

"2023-07-04T12:49:15Z"

Last modified on March 23, 2026