Add filters based on the query

Sometimes, specific terms can act as cues that you can use to filter search results. You can use positive, negative, or numerical filters:

Positive filters include a specific subset of matching records in the results. For example, if a user types “diet” on a restaurant website, return every record that has “low-carb” or “low-fat”.
Negative filters exclude matching records from results. For example, if a user types “gluten-free” on a restaurant website, you could filter out any gluten-containing meal.
Numerical filters convert text queries into a numerical range. For example, if a user types “cheap” on a website for kitchen appliances, you could filter out anything costing more than $50.

Positive filters

If you want to filter out every non-diet-friendly meal whenever user’s search queries contain the term “diet”, you could use the _tags attribute to categorize meals depending on their individual qualities:

JSON

[
  {
    "name": "Chicken Stuffed Baked Avocados",
    "restaurant": "The Hive",
    "_tags": ["low-carb"]
  },
  {
    "name": "Spinach Quiche",
    "restaurant": "Bert's Inn",
    "_tags": ["low-carb", "vegetarian"]
  },
  {
    "name": "Pizza Chicken Bake",
    "restaurant": "Millbrook Deli",
    "_tags": ["cheese"]
  },
  {
    "name": "Strawberry Sorbet",
    "restaurant": "The Hive",
    "_tags": ["low-fat", "vegetarian", "vegan"]
  }
]

When users include the term “diet” in their search, you want to automatically return every record that has “low-carb” or “low-fat” in their _tags attribute. Because _tags is already optimized for filtering, you don’t have to set it as an attribute for faceting. You can directly create a new Rule that detects the term “diet” in a query and applies a positive filter on tags “low-carb” and “low-fat”.

To use the term “diet” only for filtering and not as a search term, add a consequence in your rule to remove the word from your query.

Using the API

To run the code examples on this page, install the latest API client. To add a rule, use the saveRule method. When creating a rule, you must define a condition and a consequence.

var response = await client.SaveRuleAsync(
  "INDEX_NAME",
  "diet-rule",
  new Rule
  {
    ObjectID = "diet-rule",
    Conditions = new List<Condition>
    {
      new Condition { Pattern = "diet", Anchoring = Enum.Parse<Anchoring>("Contains") },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        Filters = "'low-carb' OR 'low-fat'",
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject
          {
            Edits = new List<Edit>
            {
              new Edit { Type = Enum.Parse<EditType>("Remove"), Delete = "diet" },
            },
          }
        ),
      },
    },
  }
);

final response = await client.saveRule(
  indexName: "INDEX_NAME",
  objectID: "diet-rule",
  rule: Rule(
    objectID: "diet-rule",
    conditions: [
      Condition(
        pattern: "diet",
        anchoring: Anchoring.fromJson("contains"),
      ),
    ],
    consequence: Consequence(
      params: ConsequenceParams(
        filters: "'low-carb' OR 'low-fat'",
        query: ConsequenceQueryObject(
          edits: [
            Edit(
              type: EditType.fromJson("remove"),
              delete: "diet",
            ),
          ],
        ),
      ),
    ),
  ),
);

response, err := client.SaveRule(client.NewApiSaveRuleRequest(
  "INDEX_NAME", "diet-rule",
  search.NewEmptyRule().SetObjectID("diet-rule").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("diet").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetFilters("'low-carb' OR 'low-fat'").SetQuery(search.ConsequenceQueryObjectAsConsequenceQuery(
        search.NewEmptyConsequenceQueryObject().SetEdits(
          []search.Edit{*search.NewEmptyEdit().SetType(search.EditType("remove")).SetDelete("diet")})))))))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.saveRule(
  "INDEX_NAME",
  "diet-rule",
  new Rule()
    .setObjectID("diet-rule")
    .setConditions(Arrays.asList(new Condition().setPattern("diet").setAnchoring(Anchoring.CONTAINS)))
    .setConsequence(
      new Consequence().setParams(
        new ConsequenceParams()
          .setFilters("'low-carb' OR 'low-fat'")
          .setQuery(new ConsequenceQueryObject().setEdits(Arrays.asList(new Edit().setType(EditType.REMOVE).setDelete("diet"))))
      )
    )
);

const response = await client.saveRule({
  indexName: 'indexName',
  objectID: 'diet-rule',
  rule: {
    objectID: 'diet-rule',
    conditions: [{ pattern: 'diet', anchoring: 'contains' }],
    consequence: {
      params: { filters: "'low-carb' OR 'low-fat'", query: { edits: [{ type: 'remove', delete: 'diet' }] } },
    },
  },
});

var response =
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "diet-rule",
    rule =
      Rule(
        objectID = "diet-rule",
        conditions =
          listOf(
            Condition(
              pattern = "diet",
              anchoring = Anchoring.entries.first { it.value == "contains" },
            )
          ),
        consequence =
          Consequence(
            params =
              ConsequenceParams(
                filters = "'low-carb' OR 'low-fat'",
                query =
                  ConsequenceQueryObject(
                    edits =
                      listOf(
                        Edit(
                          type = EditType.entries.first { it.value == "remove" },
                          delete = "diet",
                        )
                      )
                  ),
              )
          ),
      ),
  )

$response = $client->saveRule(
    'INDEX_NAME',
    'diet-rule',
    ['objectID' => 'diet-rule',
        'conditions' => [
            ['pattern' => 'diet',
                'anchoring' => 'contains',
            ],
        ],
        'consequence' => ['params' => ['filters' => "'low-carb' OR 'low-fat'",
            'query' => ['edits' => [
                ['type' => 'remove',
                    'delete' => 'diet',
                ],
            ],
            ],
        ],
        ],
    ],
);

response = client.save_rule(
    index_name="INDEX_NAME",
    object_id="diet-rule",
    rule={
        "objectID": "diet-rule",
        "conditions": [
            {
                "pattern": "diet",
                "anchoring": "contains",
            },
        ],
        "consequence": {
            "params": {
                "filters": "'low-carb' OR 'low-fat'",
                "query": {
                    "edits": [
                        {
                            "type": "remove",
                            "delete": "diet",
                        },
                    ],
                },
            },
        },
    },
)

response = client.save_rule(
  "INDEX_NAME",
  "diet-rule",
  Algolia::Search::Rule.new(
    algolia_object_id: "diet-rule",
    conditions: [Algolia::Search::Condition.new(pattern: "diet", anchoring: "contains")],
    consequence: Algolia::Search::Consequence.new(
      params: Algolia::Search::ConsequenceParams.new(
        filters: "'low-carb' OR 'low-fat'",
        query: Algolia::Search::ConsequenceQueryObject.new(
          edits: [Algolia::Search::Edit.new(type: "remove", delete: "diet")]
        )
      )
    )
  )
)

val response = Await.result(
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "diet-rule",
    rule = Rule(
      objectID = "diet-rule",
      conditions = Some(
        Seq(
          Condition(
            pattern = Some("diet"),
            anchoring = Some(Anchoring.withName("contains"))
          )
        )
      ),
      consequence = Consequence(
        params = Some(
          ConsequenceParams(
            filters = Some("'low-carb' OR 'low-fat'"),
            query = Some(
              ConsequenceQueryObject(
                edits = Some(
                  Seq(
                    Edit(
                      `type` = Some(EditType.withName("remove")),
                      delete = Some("diet")
                    )
                  )
                )
              )
            )
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

let response = try await client.saveRule(
    indexName: "INDEX_NAME",
    objectID: "diet-rule",
    rule: Rule(
        objectID: "diet-rule",
        conditions: [SearchCondition(pattern: "diet", anchoring: SearchAnchoring.contains)],
        consequence: SearchConsequence(params: SearchConsequenceParams(
            filters: "'low-carb' OR 'low-fat'",
            query: SearchConsequenceQuery
                .searchConsequenceQueryObject(SearchConsequenceQueryObject(edits: [SearchEdit(
                    type: SearchEditType.remove,
                    delete: "diet"
                )]))
        ))
    )
)

Using the dashboard

You can add rules from the Algolia dashboard using either the Visual Editor or the Manual Editor.

Visual Editor
Manual Editor

In the Algolia dashboard, select your application and index, open Rules, and select New rule > Visual Editor.
Click Set query condition(s), select contains, and enter diet. Click Apply.
In Consequences, select Filter results. Select _tags as the attribute and low-carb as the value. Add low-fat as another value and join the values with Or. Click Apply.
Click Add Consequence, expand More consequences, and select Remove word. Enter diet in Word(s) and click Apply.
Review the results, click Review and Publish, and click Publish.

Go to the Algolia dashboard and select your Algolia . On the left sidebar, select Search, select your index, and open Rules. Select Create your first rule or New rule, then select Manual Editor.
In Condition(s), keep Query contains and enter diet.
In Consequence(s), click Add consequence and select Add Query Parameter. Enter { "filters": "'low-carb' OR 'low-fat'" }.
Click Add consequence again and select Remove Word. Enter diet.
Save your changes.

Negative filters

To exclude gluten-containing foods from the search results when a user searches for gluten-free meals, do the following:

Create an allergens attribute (with “gluten” as one of the potential values).
Create a rule that filters out records with “gluten” in that attribute.

Example records

JSON

[
  {
    "name": "Pasta Bolognese",
    "restaurant": "Millbrook Deli",
    "allergens": ["eggs", "lactose"]
  },
  {
    "name": "Breakfast Waffles",
    "restaurant": "The Hive",
    "allergens": ["gluten", "lactose"]
  }
]

Using the API

Set allergens as an attributesForFaceting in your index:

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings { AttributesForFaceting = new List<string> { "allergens" } }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    attributesForFaceting: [
      "allergens",
    ],
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetAttributesForFaceting(
    []string{"allergens"})))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings(
  "INDEX_NAME",
  new IndexSettings().setAttributesForFaceting(Arrays.asList("allergens"))
);

const response = await client.setSettings({
  indexName: 'INDEX_NAME',
  indexSettings: { attributesForFaceting: ['allergens'] },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(attributesForFaceting = listOf("allergens")),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['attributesForFaceting' => [
        'allergens',
    ],
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "attributesForFaceting": [
            "allergens",
        ],
    },
)

response = client.set_settings(
  "INDEX_NAME",
  Algolia::Search::IndexSettings.new(attributes_for_faceting: ["allergens"])
)

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      attributesForFaceting = Some(Seq("allergens"))
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(attributesForFaceting: ["allergens"])
)

Use the saveRule method to create a rule that detects the term “gluten-free” in a query and applies a negative filter on facet value allergens:gluten.
Add a consequence in your rule to remove the word “gluten-free” from your query. This way, it won’t be used as a search term, only for filtering purposes.

var response = await client.SaveRuleAsync(
  "INDEX_NAME",
  "gluten-free-rule",
  new Rule
  {
    ObjectID = "gluten-free-rule",
    Conditions = new List<Condition>
    {
      new Condition { Pattern = "gluten-free", Anchoring = Enum.Parse<Anchoring>("Contains") },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        Filters = "NOT allergens:gluten",
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject
          {
            Edits = new List<Edit>
            {
              new Edit { Type = Enum.Parse<EditType>("Remove"), Delete = "gluten-free" },
            },
          }
        ),
      },
    },
  }
);

final response = await client.saveRule(
  indexName: "INDEX_NAME",
  objectID: "gluten-free-rule",
  rule: Rule(
    objectID: "gluten-free-rule",
    conditions: [
      Condition(
        pattern: "gluten-free",
        anchoring: Anchoring.fromJson("contains"),
      ),
    ],
    consequence: Consequence(
      params: ConsequenceParams(
        filters: "NOT allergens:gluten",
        query: ConsequenceQueryObject(
          edits: [
            Edit(
              type: EditType.fromJson("remove"),
              delete: "gluten-free",
            ),
          ],
        ),
      ),
    ),
  ),
);

response, err := client.SaveRule(client.NewApiSaveRuleRequest(
  "INDEX_NAME", "gluten-free-rule",
  search.NewEmptyRule().SetObjectID("gluten-free-rule").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("gluten-free").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetFilters("NOT allergens:gluten").SetQuery(search.ConsequenceQueryObjectAsConsequenceQuery(
        search.NewEmptyConsequenceQueryObject().SetEdits(
          []search.Edit{*search.NewEmptyEdit().SetType(search.EditType("remove")).SetDelete("gluten-free")})))))))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.saveRule(
  "INDEX_NAME",
  "gluten-free-rule",
  new Rule()
    .setObjectID("gluten-free-rule")
    .setConditions(Arrays.asList(new Condition().setPattern("gluten-free").setAnchoring(Anchoring.CONTAINS)))
    .setConsequence(
      new Consequence().setParams(
        new ConsequenceParams()
          .setFilters("NOT allergens:gluten")
          .setQuery(new ConsequenceQueryObject().setEdits(Arrays.asList(new Edit().setType(EditType.REMOVE).setDelete("gluten-free"))))
      )
    )
);

const response = await client.saveRule({
  indexName: 'indexName',
  objectID: 'gluten-free-rule',
  rule: {
    objectID: 'gluten-free-rule',
    conditions: [{ pattern: 'gluten-free', anchoring: 'contains' }],
    consequence: {
      params: { filters: 'NOT allergens:gluten', query: { edits: [{ type: 'remove', delete: 'gluten-free' }] } },
    },
  },
});

var response =
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "gluten-free-rule",
    rule =
      Rule(
        objectID = "gluten-free-rule",
        conditions =
          listOf(
            Condition(
              pattern = "gluten-free",
              anchoring = Anchoring.entries.first { it.value == "contains" },
            )
          ),
        consequence =
          Consequence(
            params =
              ConsequenceParams(
                filters = "NOT allergens:gluten",
                query =
                  ConsequenceQueryObject(
                    edits =
                      listOf(
                        Edit(
                          type = EditType.entries.first { it.value == "remove" },
                          delete = "gluten-free",
                        )
                      )
                  ),
              )
          ),
      ),
  )

$response = $client->saveRule(
    'INDEX_NAME',
    'gluten-free-rule',
    ['objectID' => 'gluten-free-rule',
        'conditions' => [
            ['pattern' => 'gluten-free',
                'anchoring' => 'contains',
            ],
        ],
        'consequence' => ['params' => ['filters' => 'NOT allergens:gluten',
            'query' => ['edits' => [
                ['type' => 'remove',
                    'delete' => 'gluten-free',
                ],
            ],
            ],
        ],
        ],
    ],
);

response = client.save_rule(
    index_name="INDEX_NAME",
    object_id="gluten-free-rule",
    rule={
        "objectID": "gluten-free-rule",
        "conditions": [
            {
                "pattern": "gluten-free",
                "anchoring": "contains",
            },
        ],
        "consequence": {
            "params": {
                "filters": "NOT allergens:gluten",
                "query": {
                    "edits": [
                        {
                            "type": "remove",
                            "delete": "gluten-free",
                        },
                    ],
                },
            },
        },
    },
)

response = client.save_rule(
  "INDEX_NAME",
  "gluten-free-rule",
  Algolia::Search::Rule.new(
    algolia_object_id: "gluten-free-rule",
    conditions: [Algolia::Search::Condition.new(pattern: "gluten-free", anchoring: "contains")],
    consequence: Algolia::Search::Consequence.new(
      params: Algolia::Search::ConsequenceParams.new(
        filters: "NOT allergens:gluten",
        query: Algolia::Search::ConsequenceQueryObject.new(
          edits: [Algolia::Search::Edit.new(type: "remove", delete: "gluten-free")]
        )
      )
    )
  )
)

val response = Await.result(
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "gluten-free-rule",
    rule = Rule(
      objectID = "gluten-free-rule",
      conditions = Some(
        Seq(
          Condition(
            pattern = Some("gluten-free"),
            anchoring = Some(Anchoring.withName("contains"))
          )
        )
      ),
      consequence = Consequence(
        params = Some(
          ConsequenceParams(
            filters = Some("NOT allergens:gluten"),
            query = Some(
              ConsequenceQueryObject(
                edits = Some(
                  Seq(
                    Edit(
                      `type` = Some(EditType.withName("remove")),
                      delete = Some("gluten-free")
                    )
                  )
                )
              )
            )
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

let response = try await client.saveRule(
    indexName: "INDEX_NAME",
    objectID: "gluten-free-rule",
    rule: Rule(
        objectID: "gluten-free-rule",
        conditions: [SearchCondition(pattern: "gluten-free", anchoring: SearchAnchoring.contains)],
        consequence: SearchConsequence(params: SearchConsequenceParams(
            filters: "NOT allergens:gluten",
            query: SearchConsequenceQuery
                .searchConsequenceQueryObject(SearchConsequenceQueryObject(edits: [SearchEdit(
                    type: SearchEditType.remove,
                    delete: "gluten-free"
                )]))
        ))
    )
)

Using the dashboard

You can add rules from the Algolia dashboard using either the Visual Editor or the Manual Editor. Before creating the rule, open Configuration > Filtering and Faceting > Facets for your index and add the allergens attribute.

Visual Editor
Manual Editor

In the Algolia dashboard, select your application and index, open Rules, and select New rule > Visual Editor.
Click Set query condition(s), select contains, and enter gluten-free. Click Apply.
In Consequences, select Filter results. Select allergens as the attribute, is not as the operator, and gluten as the value. Click Apply.
Click Add Consequence, expand More consequences, and select Remove word. Enter gluten-free in Word(s) and click Apply.
Review the results, click Review and Publish, and click Publish.

Open Rules, select Create your first rule or New rule, and select Manual Editor.
In Condition(s), keep Query selected, select Contains, and enter gluten-free.
In Consequence(s), click Add consequence and select Add Query Parameter. Enter { "filters": "NOT allergens:gluten" }.
Click Add consequence again and select Remove Word. Enter gluten-free.
Save your changes.

Numerical filters

Consider the query “cheap toaster 800w”. You can use Rules to filter the results by “toaster” and “prices under $10” so that the only textual search is the remaining term, “800w”, which could further be used to limit the results with that wattage.

Rule

If query = "cheap toaster" then price < 10 and product_type:toaster.

This requires two rules because each query term applies a different filter.

Using the API

var response = await client.SaveRuleAsync(
  "INDEX_NAME",
  "cheap",
  new Rule
  {
    ObjectID = "cheap",
    Conditions = new List<Condition>
    {
      new Condition { Pattern = "cheap", Anchoring = Enum.Parse<Anchoring>("Contains") },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject { Remove = new List<string> { "cheap" } }
        ),
        Filters = "price < 10",
      },
    },
  }
);

final response = await client.saveRule(
  indexName: "INDEX_NAME",
  objectID: "cheap",
  rule: Rule(
    objectID: "cheap",
    conditions: [
      Condition(
        pattern: "cheap",
        anchoring: Anchoring.fromJson("contains"),
      ),
    ],
    consequence: Consequence(
      params: ConsequenceParams(
        query: ConsequenceQueryObject(
          remove: [
            "cheap",
          ],
        ),
        filters: "price < 10",
      ),
    ),
  ),
);

response, err := client.SaveRule(client.NewApiSaveRuleRequest(
  "INDEX_NAME", "cheap",
  search.NewEmptyRule().SetObjectID("cheap").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("cheap").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetQuery(search.ConsequenceQueryObjectAsConsequenceQuery(
        search.NewEmptyConsequenceQueryObject().SetRemove(
          []string{"cheap"}))).SetFilters("price < 10")))))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.saveRule(
  "INDEX_NAME",
  "cheap",
  new Rule()
    .setObjectID("cheap")
    .setConditions(Arrays.asList(new Condition().setPattern("cheap").setAnchoring(Anchoring.CONTAINS)))
    .setConsequence(
      new Consequence().setParams(
        new ConsequenceParams().setQuery(new ConsequenceQueryObject().setRemove(Arrays.asList("cheap"))).setFilters("price < 10")
      )
    )
);

const response = await client.saveRule({
  indexName: 'indexName',
  objectID: 'cheap',
  rule: {
    objectID: 'cheap',
    conditions: [{ pattern: 'cheap', anchoring: 'contains' }],
    consequence: { params: { query: { remove: ['cheap'] }, filters: 'price < 10' } },
  },
});

var response =
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "cheap",
    rule =
      Rule(
        objectID = "cheap",
        conditions =
          listOf(
            Condition(
              pattern = "cheap",
              anchoring = Anchoring.entries.first { it.value == "contains" },
            )
          ),
        consequence =
          Consequence(
            params =
              ConsequenceParams(
                query = ConsequenceQueryObject(remove = listOf("cheap")),
                filters = "price < 10",
              )
          ),
      ),
  )

$response = $client->saveRule(
    'INDEX_NAME',
    'cheap',
    ['objectID' => 'cheap',
        'conditions' => [
            ['pattern' => 'cheap',
                'anchoring' => 'contains',
            ],
        ],
        'consequence' => ['params' => ['query' => ['remove' => [
            'cheap',
        ],
        ],
            'filters' => 'price < 10',
        ],
        ],
    ],
);

response = client.save_rule(
    index_name="INDEX_NAME",
    object_id="cheap",
    rule={
        "objectID": "cheap",
        "conditions": [
            {
                "pattern": "cheap",
                "anchoring": "contains",
            },
        ],
        "consequence": {
            "params": {
                "query": {
                    "remove": [
                        "cheap",
                    ],
                },
                "filters": "price < 10",
            },
        },
    },
)

response = client.save_rule(
  "INDEX_NAME",
  "cheap",
  Algolia::Search::Rule.new(
    algolia_object_id: "cheap",
    conditions: [Algolia::Search::Condition.new(pattern: "cheap", anchoring: "contains")],
    consequence: Algolia::Search::Consequence.new(
      params: Algolia::Search::ConsequenceParams.new(
        query: Algolia::Search::ConsequenceQueryObject.new(remove: ["cheap"]),
        filters: "price < 10"
      )
    )
  )
)

val response = Await.result(
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "cheap",
    rule = Rule(
      objectID = "cheap",
      conditions = Some(
        Seq(
          Condition(
            pattern = Some("cheap"),
            anchoring = Some(Anchoring.withName("contains"))
          )
        )
      ),
      consequence = Consequence(
        params = Some(
          ConsequenceParams(
            query = Some(
              ConsequenceQueryObject(
                remove = Some(Seq("cheap"))
              )
            ),
            filters = Some("price < 10")
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

let response = try await client.saveRule(
    indexName: "INDEX_NAME",
    objectID: "cheap",
    rule: Rule(
        objectID: "cheap",
        conditions: [SearchCondition(pattern: "cheap", anchoring: SearchAnchoring.contains)],
        consequence: SearchConsequence(params: SearchConsequenceParams(
            filters: "price < 10",
            query: SearchConsequenceQuery
                .searchConsequenceQueryObject(SearchConsequenceQueryObject(remove: ["cheap"]))
        ))
    )
)

Using the dashboard

You can configure this example from the Algolia dashboard using either the Visual Editor or the Manual Editor.

Preparation

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Search.
Select your Algolia index and open the Configuration tab.
On the Filtering and Facets page, click Add an attribute and select the product_type attribute. Repeat to add price.

Visual Editor
Manual Editor

In the Visual Editor, set up separate rules for toaster and cheap.

In the Algolia dashboard, select your application and index, open Rules, and select New rule > Visual Editor.
Click Set query condition(s), select contains, and enter toaster. Click Apply.
In Consequences, select Filter results. Select product_type as the attribute and toaster as the value. Click Apply.
Click Add Consequence, expand More consequences, and select Remove word. Enter toaster in Word(s), then click Apply.
Review the results, click Review and Publish, and click Publish.

Repeat these steps to create the second rule. Use cheap for the condition and removed word, and filter on price < 10.

In the Manual Editor, set up separate rules for toaster and cheap.

Open Rules, select Create your first rule or New rule, and select Manual Editor.
In Condition(s), keep Query selected, select Contains, and enter toaster.
In Consequence(s), click Add consequence and select Add Query Parameter. Enter { "filters": "product_type:toaster" }.
Click Add consequence again and select Remove Word. Enter toaster.
Save your changes.

Repeat these steps to create the second rule. Use cheap for the condition and removed word, and enter { "filters": "price<10" } as the query parameter.

Search and Discovery platform

Optimization and Personalization

AI-powered experiences

Production and scale

Add filters based on the query

Positive filters

Using the API

Using the dashboard

Negative filters

Example records

Using the API

Using the dashboard

Numerical filters

Rule

Using the API

Using the dashboard

Preparation

See also

​Positive filters

​Using the API

​Using the dashboard

​Negative filters

​Example records

​Using the API

​Using the dashboard

​Numerical filters

​Rule

​Using the API

​Using the dashboard

​Preparation

​See also

Positive filters

Using the API

Using the dashboard

Negative filters

Example records

Using the API

Using the dashboard

Numerical filters

Rule

Using the API

Using the dashboard

Preparation

See also