Guides / Managing results / Rules / Detecting intent

Feb 06, 2025

Dynamic filtering with Rules

How to create a dynamic filtering rule

In this example for a product catalog, you create a rule that displays products with the “red” value in the color facet if the query contains the word “red”.

Using the example dataset, this rule ensures that only records with “red” in the color attribute are returned. It ignores “red” in other attributes such as brand.

Query	Results
red	FM, Clothing, LondonLook, Red, 21.99 The Mandal, Toaster, Black & Decker, Red, 149.99

Using the dashboard

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Search.
Select your Algolia index:
Click Rules in the left sidebar menu.
Select Create your first rule or New rule. In the drop-down menu, click the Manual Editor option.
In the Condition(s) section, with Query toggled on, select Contains in the drop-down menu, and enter “red” in the input field.
In the Consequence(s) section:
- Click Add consequence and select Add Query Parameter.
- In the input field that appears, add the JSON parameters you want to apply when the user’s query matches the Rule: {"filters":"color:red"}
- Click Add consequence and select Remove Word.
- Type or select “red” in the input field.
If you click Optional under Consequence(s), this will display non-red products after the red ones. For more information, see Using optional filters.
Save your changes.

Using the API

This example uses the filters parameter. With this approach, you need one rule per filter value. If you have 10 color options, you need 10 rules, one for each color.

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var response = await client.SaveRuleAsync(
  "ALGOLIA_INDEX_NAME",
  "red-color",
  new Rule
  {
    ObjectID = "red-color",
    Conditions = new List<Condition>
    {
      new Condition { Pattern = "red", Anchoring = Enum.Parse<Anchoring>("Contains") },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject { Remove = new List<string> { "red" } }
        ),
        Filters = "color:red",
      },
    },
  }
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
final response = await client.saveRule(
  indexName: "ALGOLIA_INDEX_NAME",
  objectID: "red-color",
  rule: Rule(
    objectID: "red-color",
    conditions: [
      Condition(
        pattern: "red",
        anchoring: Anchoring.fromJson("contains"),
      ),
    ],
    consequence: Consequence(
      params: ConsequenceParams(
        query: ConsequenceQueryObject(
          remove: [
            "red",
          ],
        ),
        filters: "color:red",
      ),
    ),
  ),
);

1
2
3
4
5
6
7
8
9
10
11
12
response, err := client.SaveRule(client.NewApiSaveRuleRequest(
  "ALGOLIA_INDEX_NAME", "red-color",
  search.NewEmptyRule().SetObjectID("red-color").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("red").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetQuery(search.ConsequenceQueryObjectAsConsequenceQuery(
        search.NewEmptyConsequenceQueryObject().SetRemove(
          []string{"red"}))).SetFilters("color:red")))))
if err != nil {
  // handle the eventual error
  panic(err)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
client.saveRule(
  "ALGOLIA_INDEX_NAME",
  "red-color",
  new Rule()
    .setObjectID("red-color")
    .setConditions(Arrays.asList(new Condition().setPattern("red").setAnchoring(Anchoring.CONTAINS)))
    .setConsequence(
      new Consequence()
        .setParams(
          new ConsequenceParams().setQuery(new ConsequenceQueryObject().setRemove(Arrays.asList("red"))).setFilters("color:red")
        )
    )
);

1
2
3
4
5
6
7
8
9
const response = await client.saveRule({
  indexName: 'indexName',
  objectID: 'red-color',
  rule: {
    objectID: 'red-color',
    conditions: [{ pattern: 'red', anchoring: 'contains' }],
    consequence: { params: { query: { remove: ['red'] }, filters: 'color:red' } },
  },
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var response = client.saveRule(
  indexName = "ALGOLIA_INDEX_NAME",
  objectID = "red-color",
  rule = Rule(
    objectID = "red-color",
    conditions = listOf(
      Condition(
        pattern = "red",
        anchoring = Anchoring.entries.first { it.value == "contains" },
      ),
    ),
    consequence = Consequence(
      params = ConsequenceParams(
        query = ConsequenceQueryObject(
          remove = listOf("red"),
        ),
        filters = "color:red",
      ),
    ),
  ),
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
$response = $client->saveRule(
    'ALGOLIA_INDEX_NAME',
    'red-color',
    ['objectID' => 'red-color',
        'conditions' => [
            ['pattern' => 'red',
                'anchoring' => 'contains',
            ],
        ],
        'consequence' => ['params' => ['query' => ['remove' => [
            'red',
        ],
        ],
            'filters' => 'color:red',
        ],
        ],
    ],
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
response = client.save_rule(
    index_name="ALGOLIA_INDEX_NAME",
    object_id="red-color",
    rule={
        "objectID": "red-color",
        "conditions": [
            {
                "pattern": "red",
                "anchoring": "contains",
            },
        ],
        "consequence": {
            "params": {
                "query": {
                    "remove": [
                        "red",
                    ],
                },
                "filters": "color:red",
            },
        },
    },
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
response = client.save_rule(
  "ALGOLIA_INDEX_NAME",
  "red-color",
  Algolia::Search::Rule.new(
    algolia_object_id: "red-color",
    conditions: [Algolia::Search::Condition.new(pattern: "red", anchoring: "contains")],
    consequence: Algolia::Search::Consequence.new(
      params: Algolia::Search::ConsequenceParams.new(
        query: Algolia::Search::ConsequenceQueryObject.new(remove: ["red"]),
        filters: "color:red"
      )
    )
  )
)

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
val response = Await.result(
  client.saveRule(
    indexName = "ALGOLIA_INDEX_NAME",
    objectID = "red-color",
    rule = Rule(
      objectID = "red-color",
      conditions = Some(
        Seq(
          Condition(
            pattern = Some("red"),
            anchoring = Some(Anchoring.withName("contains"))
          )
        )
      ),
      consequence = Consequence(
        params = Some(
          ConsequenceParams(
            query = Some(
              ConsequenceQueryObject(
                remove = Some(Seq("red"))
              )
            ),
            filters = Some("color:red")
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

1
2
3
4
5
6
7
8
9
10
11
12
13
let response = try await client.saveRule(
    indexName: "ALGOLIA_INDEX_NAME",
    objectID: "red-color",
    rule: Rule(
        objectID: "red-color",
        conditions: [SearchCondition(pattern: "red", anchoring: SearchAnchoring.contains)],
        consequence: SearchConsequence(params: SearchConsequenceParams(
            filters: "color:red",
            query: SearchConsequenceQuery
                .searchConsequenceQueryObject(SearchConsequenceQueryObject(remove: ["red"]))
        ))
    )
)

Examples

The following examples explore:

One rule per facet
Numerical dynamic filtering
Tagged filters

Instead of creating one rule per facet value, this approach uses one rule for the color facet.

Using the example dataset, this single rule ensures that any record with any matching color value in the color attribute will be returned.

Query	Results
red	FM, Clothing, LondonLook, Red, 21.99 The Mandal, Toaster, Black & Decker, Red, 149.99
black	Will Carpenter, T-shirt, Red or Dead, Black, 199.99

Using the dashboard

Create a new rule. See how to create a dynamic filtering rule.
In the Manual Editor’s Condition(s), click the box next to Query contains and select the option Add Facet “color” from the drop-down menu.
In the Consequence(s) section:
- Click Add consequence and select Filter/Boost Matching Attributes.
- Click the Filter box that appears and select the option Add Facet “color” from the drop-down menu.
Save your changes.

Using the API

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var response = await client.SaveRuleAsync(
  "ALGOLIA_INDEX_NAME",
  "color-facets",
  new Rule
  {
    ObjectID = "color-facets",
    Conditions = new List<Condition> { new Condition { Pattern = "{facet:color}" } },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        AutomaticFacetFilters = new AutomaticFacetFilters(
          new List<AutomaticFacetFilter> { new AutomaticFacetFilter { Facet = "color" } }
        ),
      },
    },
  }
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
final response = await client.saveRule(
  indexName: "ALGOLIA_INDEX_NAME",
  objectID: "color-facets",
  rule: Rule(
    objectID: "color-facets",
    conditions: [
      Condition(
        pattern: "{facet:color}",
      ),
    ],
    consequence: Consequence(
      params: ConsequenceParams(
        automaticFacetFilters: [
          AutomaticFacetFilter(
            facet: "color",
          ),
        ],
      ),
    ),
  ),
);

1
2
3
4
5
6
7
8
9
10
11
response, err := client.SaveRule(client.NewApiSaveRuleRequest(
  "ALGOLIA_INDEX_NAME", "color-facets",
  search.NewEmptyRule().SetObjectID("color-facets").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("{facet:color}")}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetAutomaticFacetFilters(search.ArrayOfAutomaticFacetFilterAsAutomaticFacetFilters(
        []search.AutomaticFacetFilter{*search.NewEmptyAutomaticFacetFilter().SetFacet("color")}))))))
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
client.saveRule(
  "ALGOLIA_INDEX_NAME",
  "color-facets",
  new Rule()
    .setObjectID("color-facets")
    .setConditions(Arrays.asList(new Condition().setPattern("{facet:color}")))
    .setConsequence(
      new Consequence()
        .setParams(
          new ConsequenceParams()
            .setAutomaticFacetFilters(
              AutomaticFacetFilters.ofListOfAutomaticFacetFilter(Arrays.asList(new AutomaticFacetFilter().setFacet("color")))
            )
        )
    )
);

1
2
3
4
5
6
7
8
9
const response = await client.saveRule({
  indexName: 'indexName',
  objectID: 'color-facets',
  rule: {
    objectID: 'color-facets',
    conditions: [{ pattern: '{facet:color}' }],
    consequence: { params: { automaticFacetFilters: [{ facet: 'color' }] } },
  },
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var response = client.saveRule(
  indexName = "ALGOLIA_INDEX_NAME",
  objectID = "color-facets",
  rule = Rule(
    objectID = "color-facets",
    conditions = listOf(
      Condition(
        pattern = "{facet:color}",
      ),
    ),
    consequence = Consequence(
      params = ConsequenceParams(
        automaticFacetFilters = AutomaticFacetFilters.ofListOfAutomaticFacetFilter(
          listOf(
            AutomaticFacetFilter(
              facet = "color",
            ),
          ),
        ),
      ),
    ),
  ),
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$response = $client->saveRule(
    'ALGOLIA_INDEX_NAME',
    'color-facets',
    ['objectID' => 'color-facets',
        'conditions' => [
            ['pattern' => '{facet:color}',
            ],
        ],
        'consequence' => ['params' => ['automaticFacetFilters' => [
            ['facet' => 'color',
            ],
        ],
        ],
        ],
    ],
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
response = client.save_rule(
    index_name="ALGOLIA_INDEX_NAME",
    object_id="color-facets",
    rule={
        "objectID": "color-facets",
        "conditions": [
            {
                "pattern": "{facet:color}",
            },
        ],
        "consequence": {
            "params": {
                "automaticFacetFilters": [
                    {
                        "facet": "color",
                    },
                ],
            },
        },
    },
)

1
2
3
4
5
6
7
8
9
10
11
12
13
response = client.save_rule(
  "ALGOLIA_INDEX_NAME",
  "color-facets",
  Algolia::Search::Rule.new(
    algolia_object_id: "color-facets",
    conditions: [Algolia::Search::Condition.new(pattern: "{facet:color}")],
    consequence: Algolia::Search::Consequence.new(
      params: Algolia::Search::ConsequenceParams.new(
        automatic_facet_filters: [Algolia::Search::AutomaticFacetFilter.new(facet: "color")]
      )
    )
  )
)

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
val response = Await.result(
  client.saveRule(
    indexName = "ALGOLIA_INDEX_NAME",
    objectID = "color-facets",
    rule = Rule(
      objectID = "color-facets",
      conditions = Some(
        Seq(
          Condition(
            pattern = Some("{facet:color}")
          )
        )
      ),
      consequence = Consequence(
        params = Some(
          ConsequenceParams(
            automaticFacetFilters = Some(
              AutomaticFacetFilters(
                Seq(
                  AutomaticFacetFilter(
                    facet = "color"
                  )
                )
              )
            )
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
let response = try await client.saveRule(
    indexName: "ALGOLIA_INDEX_NAME",
    objectID: "color-facets",
    rule: Rule(
        objectID: "color-facets",
        conditions: [SearchCondition(pattern: "{facet:color}")],
        consequence: SearchConsequence(
            params: SearchConsequenceParams(
                automaticFacetFilters: SearchAutomaticFacetFilters
                    .arrayOfSearchAutomaticFacetFilter([SearchAutomaticFacetFilter(facet: "color")])
            )
        )
    )
)

Numerical dynamic filtering

Consider a user entering the query “cheap toaster 800w”. You can use two rules together to filter results by:

The product type: “Toaster”
“Cheapness”. You determine that a cheap product is any product that costs less than $15.

Using the example dataset, these rules ensure that any product that costs less than $15, has the product_type “Toaster” and includes the phrase “800w” is returned.

Query	Results
cheap toaster 800w	Essentials 800w, Toaster, Daewoo, Black, 14.99

Using the dashboard

Create the first rule:

Create a new rule. See how to create a dynamic filtering rule.
In the Manual Editor’s Condition(s), with Query toggled on, select Contains in the drop-down menu, and enter “toaster” in the input field.
In the Consequence(s) section:
- Click Add consequence and select Add Query Parameter.
- In the input field that appears, enter {"filters":"product_type:toaster"}
- Click Add consequence and select Remove Word.
- Type or select “toaster” in the input field.
Save your changes.

Create the second rule:

Create a new rule
In the Manual Editor’s Condition(s), with Query toggled on, select Contains in the drop-down menu, and enter “cheap” in the input field.
In the Consequence(s) section:
- Click Add consequence and select Add Query Parameter.
- In the input field that appears, enter {"filters":"price < 10"}
- Click Add consequence and select Remove Word.
- Type or select “cheap” in the input field.
Save your changes.

Using the API

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
var response = await client.SaveRulesAsync(
  "ALGOLIA_INDEX_NAME",
  new List<Rule>
  {
    new Rule
    {
      ObjectID = "toaster",
      Conditions = new List<Condition>
      {
        new Condition { Pattern = "toaster", Anchoring = Enum.Parse<Anchoring>("Contains") },
      },
      Consequence = new Consequence
      {
        Params = new ConsequenceParams
        {
          Query = new ConsequenceQuery(
            new ConsequenceQueryObject { Remove = new List<string> { "toaster" } }
          ),
          Filters = "product_type:toaster",
        },
      },
    },
    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 < 15",
        },
      },
    },
  }
);

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
final response = await client.saveRules(
  indexName: "ALGOLIA_INDEX_NAME",
  rules: [
    Rule(
      objectID: "toaster",
      conditions: [
        Condition(
          pattern: "toaster",
          anchoring: Anchoring.fromJson("contains"),
        ),
      ],
      consequence: Consequence(
        params: ConsequenceParams(
          query: ConsequenceQueryObject(
            remove: [
              "toaster",
            ],
          ),
          filters: "product_type:toaster",
        ),
      ),
    ),
    Rule(
      objectID: "cheap",
      conditions: [
        Condition(
          pattern: "cheap",
          anchoring: Anchoring.fromJson("contains"),
        ),
      ],
      consequence: Consequence(
        params: ConsequenceParams(
          query: ConsequenceQueryObject(
            remove: [
              "cheap",
            ],
          ),
          filters: "price < 15",
        ),
      ),
    ),
  ],
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
response, err := client.SaveRules(client.NewApiSaveRulesRequest(
  "ALGOLIA_INDEX_NAME",
  []search.Rule{*search.NewEmptyRule().SetObjectID("toaster").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("toaster").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetQuery(search.ConsequenceQueryObjectAsConsequenceQuery(
        search.NewEmptyConsequenceQueryObject().SetRemove(
          []string{"toaster"}))).SetFilters("product_type:toaster"))), *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 < 15")))}))
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
client.saveRules(
  "ALGOLIA_INDEX_NAME",
  Arrays.asList(
    new Rule()
      .setObjectID("toaster")
      .setConditions(Arrays.asList(new Condition().setPattern("toaster").setAnchoring(Anchoring.CONTAINS)))
      .setConsequence(
        new Consequence()
          .setParams(
            new ConsequenceParams()
              .setQuery(new ConsequenceQueryObject().setRemove(Arrays.asList("toaster")))
              .setFilters("product_type:toaster")
          )
      ),
    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 < 15")
          )
      )
  )
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const response = await client.saveRules({
  indexName: 'ALGOLIA_INDEX_NAME',
  rules: [
    {
      objectID: 'toaster',
      conditions: [{ pattern: 'toaster', anchoring: 'contains' }],
      consequence: { params: { query: { remove: ['toaster'] }, filters: 'product_type:toaster' } },
    },
    {
      objectID: 'cheap',
      conditions: [{ pattern: 'cheap', anchoring: 'contains' }],
      consequence: { params: { query: { remove: ['cheap'] }, filters: 'price < 15' } },
    },
  ],
});

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
var response = client.saveRules(
  indexName = "ALGOLIA_INDEX_NAME",
  rules = listOf(
    Rule(
      objectID = "toaster",
      conditions = listOf(
        Condition(
          pattern = "toaster",
          anchoring = Anchoring.entries.first { it.value == "contains" },
        ),
      ),
      consequence = Consequence(
        params = ConsequenceParams(
          query = ConsequenceQueryObject(
            remove = listOf("toaster"),
          ),
          filters = "product_type:toaster",
        ),
      ),
    ),
    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 < 15",
        ),
      ),
    ),
  ),
)

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
$response = $client->saveRules(
    'ALGOLIA_INDEX_NAME',
    [
        ['objectID' => 'toaster',
            'conditions' => [
                ['pattern' => 'toaster',
                    'anchoring' => 'contains',
                ],
            ],
            'consequence' => ['params' => ['query' => ['remove' => [
                'toaster',
            ],
            ],
                'filters' => 'product_type:toaster',
            ],
            ],
        ],

        ['objectID' => 'cheap',
            'conditions' => [
                ['pattern' => 'cheap',
                    'anchoring' => 'contains',
                ],
            ],
            'consequence' => ['params' => ['query' => ['remove' => [
                'cheap',
            ],
            ],
                'filters' => 'price < 15',
            ],
            ],
        ],
    ],
);

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
response = client.save_rules(
    index_name="ALGOLIA_INDEX_NAME",
    rules=[
        {
            "objectID": "toaster",
            "conditions": [
                {
                    "pattern": "toaster",
                    "anchoring": "contains",
                },
            ],
            "consequence": {
                "params": {
                    "query": {
                        "remove": [
                            "toaster",
                        ],
                    },
                    "filters": "product_type:toaster",
                },
            },
        },
        {
            "objectID": "cheap",
            "conditions": [
                {
                    "pattern": "cheap",
                    "anchoring": "contains",
                },
            ],
            "consequence": {
                "params": {
                    "query": {
                        "remove": [
                            "cheap",
                        ],
                    },
                    "filters": "price < 15",
                },
            },
        },
    ],
)

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
response = client.save_rules(
  "ALGOLIA_INDEX_NAME",
  [
    Algolia::Search::Rule.new(
      algolia_object_id: "toaster",
      conditions: [Algolia::Search::Condition.new(pattern: "toaster", anchoring: "contains")],
      consequence: Algolia::Search::Consequence.new(
        params: Algolia::Search::ConsequenceParams.new(
          query: Algolia::Search::ConsequenceQueryObject.new(remove: ["toaster"]),
          filters: "product_type:toaster"
        )
      )
    ),
    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 < 15"
        )
      )
    )
  ]
)

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
val response = Await.result(
  client.saveRules(
    indexName = "ALGOLIA_INDEX_NAME",
    rules = Seq(
      Rule(
        objectID = "toaster",
        conditions = Some(
          Seq(
            Condition(
              pattern = Some("toaster"),
              anchoring = Some(Anchoring.withName("contains"))
            )
          )
        ),
        consequence = Consequence(
          params = Some(
            ConsequenceParams(
              query = Some(
                ConsequenceQueryObject(
                  remove = Some(Seq("toaster"))
                )
              ),
              filters = Some("product_type:toaster")
            )
          )
        )
      ),
      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 < 15")
            )
          )
        )
      )
    )
  ),
  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
23
let response = try await client.saveRules(
    indexName: "ALGOLIA_INDEX_NAME",
    rules: [
        Rule(
            objectID: "toaster",
            conditions: [SearchCondition(pattern: "toaster", anchoring: SearchAnchoring.contains)],
            consequence: SearchConsequence(params: SearchConsequenceParams(
                filters: "product_type:toaster",
                query: SearchConsequenceQuery
                    .searchConsequenceQueryObject(SearchConsequenceQueryObject(remove: ["toaster"]))
            ))
        ),
        Rule(
            objectID: "cheap",
            conditions: [SearchCondition(pattern: "cheap", anchoring: SearchAnchoring.contains)],
            consequence: SearchConsequence(params: SearchConsequenceParams(
                filters: "price < 15",
                query: SearchConsequenceQuery
                    .searchConsequenceQueryObject(SearchConsequenceQueryObject(remove: ["cheap"]))
            ))
        ),
    ]
)

Tagged filters

Consider a user who enters the query “apple headphones”. They would expect to search for results that match the term “headphones”, but only where the brand attribute matches “apple”. You can find this behavior on sites such as GitHub. It’s a great alternative to filters for users who prefer to type rather than click.

This approach is similar to one rule per facet.

Using the example dataset, this rule ensures that any record containing the phrase “headphones” that also has “Apple” in the brand attribute will be returned. It won’t return non-Apple brands, even if the phrase “Apple” appears in other attributes.

Query	Results
apple headphones	Airpods Max, Headphones, Apple, Gray, 548.99

Using the dashboard

Create a new rule as above
In the Manual Editor’s Condition(s), click the box next to Query contains and select the option Add Facet “brand” from the drop-down menu.
Clear the Apply to plurals, synonyms and typos checkbox to ensure precise matching of the brand name.
In the Consequence(s) section:
- Click Add consequence and select Filter/Boost Matching Attributes.
- Click the Filter box that appears and select the option Add Facet “brand” from the drop-down menu.
- Click Add consequence and select Remove word.
- In the input that appears, select Remove {facet:brand}.
Save your changes.

Using the API

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
var response = await client.SaveRuleAsync(
  "ALGOLIA_INDEX_NAME",
  "tagged-brand-rule",
  new Rule
  {
    Conditions = new List<Condition>
    {
      new Condition
      {
        Pattern = "brand: {facet:brand}",
        Anchoring = Enum.Parse<Anchoring>("Contains"),
        Alternatives = false,
      },
    },
    Consequence = new Consequence
    {
      Params = new ConsequenceParams
      {
        AutomaticFacetFilters = new AutomaticFacetFilters(
          new List<AutomaticFacetFilter> { new AutomaticFacetFilter { Facet = "brand" } }
        ),
        Query = new ConsequenceQuery(
          new ConsequenceQueryObject
          {
            Remove = new List<string> { "brand:", "{facet:brand}" },
          }
        ),
      },
    },
    Description = "filter on brand: {brand}",
    ObjectID = "tagged-brand-rule",
  }
);

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
final response = await client.saveRule(
  indexName: "ALGOLIA_INDEX_NAME",
  objectID: "tagged-brand-rule",
  rule: Rule(
    conditions: [
      Condition(
        pattern: "brand: {facet:brand}",
        anchoring: Anchoring.fromJson("contains"),
        alternatives: false,
      ),
    ],
    consequence: Consequence(
      params: ConsequenceParams(
        automaticFacetFilters: [
          AutomaticFacetFilter(
            facet: "brand",
          ),
        ],
        query: ConsequenceQueryObject(
          remove: [
            "brand:",
            "{facet:brand}",
          ],
        ),
      ),
    ),
    description: "filter on brand: {brand}",
    objectID: "tagged-brand-rule",
  ),
);

1
2
3
4
5
6
7
8
9
10
11
12
13
response, err := client.SaveRule(client.NewApiSaveRuleRequest(
  "ALGOLIA_INDEX_NAME", "tagged-brand-rule",
  search.NewEmptyRule().SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("brand: {facet:brand}").SetAnchoring(search.Anchoring("contains")).SetAlternatives(false)}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetAutomaticFacetFilters(search.ArrayOfAutomaticFacetFilterAsAutomaticFacetFilters(
        []search.AutomaticFacetFilter{*search.NewEmptyAutomaticFacetFilter().SetFacet("brand")})).SetQuery(search.ConsequenceQueryObjectAsConsequenceQuery(
        search.NewEmptyConsequenceQueryObject().SetRemove(
          []string{"brand:", "{facet:brand}"}))))).SetDescription("filter on brand: {brand}").SetObjectID("tagged-brand-rule")))
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
client.saveRule(
  "ALGOLIA_INDEX_NAME",
  "tagged-brand-rule",
  new Rule()
    .setConditions(
      Arrays.asList(new Condition().setPattern("brand: {facet:brand}").setAnchoring(Anchoring.CONTAINS).setAlternatives(false))
    )
    .setConsequence(
      new Consequence()
        .setParams(
          new ConsequenceParams()
            .setAutomaticFacetFilters(
              AutomaticFacetFilters.ofListOfAutomaticFacetFilter(Arrays.asList(new AutomaticFacetFilter().setFacet("brand")))
            )
            .setQuery(new ConsequenceQueryObject().setRemove(Arrays.asList("brand:", "{facet:brand}")))
        )
    )
    .setDescription("filter on brand: {brand}")
    .setObjectID("tagged-brand-rule")
);

1
2
3
4
5
6
7
8
9
10
11
12
const response = await client.saveRule({
  indexName: 'indexName',
  objectID: 'tagged-brand-rule',
  rule: {
    conditions: [{ pattern: 'brand: {facet:brand}', anchoring: 'contains', alternatives: false }],
    consequence: {
      params: { automaticFacetFilters: [{ facet: 'brand' }], query: { remove: ['brand:', '{facet:brand}'] } },
    },
    description: 'filter on brand: {brand}',
    objectID: 'tagged-brand-rule',
  },
});

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
var response = client.saveRule(
  indexName = "ALGOLIA_INDEX_NAME",
  objectID = "tagged-brand-rule",
  rule = Rule(
    conditions = listOf(
      Condition(
        pattern = "brand: {facet:brand}",
        anchoring = Anchoring.entries.first { it.value == "contains" },
        alternatives = false,
      ),
    ),
    consequence = Consequence(
      params = ConsequenceParams(
        automaticFacetFilters = AutomaticFacetFilters.ofListOfAutomaticFacetFilter(
          listOf(
            AutomaticFacetFilter(
              facet = "brand",
            ),
          ),
        ),
        query = ConsequenceQueryObject(
          remove = listOf("brand:", "{facet:brand}"),
        ),
      ),
    ),
    description = "filter on brand: {brand}",
    objectID = "tagged-brand-rule",
  ),
)

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
$response = $client->saveRule(
    'ALGOLIA_INDEX_NAME',
    'tagged-brand-rule',
    ['conditions' => [
        ['pattern' => 'brand: {facet:brand}',
            'anchoring' => 'contains',
            'alternatives' => false,
        ],
    ],
        'consequence' => ['params' => ['automaticFacetFilters' => [
            ['facet' => 'brand',
            ],
        ],
            'query' => ['remove' => [
                'brand:',

                '{facet:brand}',
            ],
            ],
        ],
        ],
        'description' => 'filter on brand: {brand}',
        'objectID' => 'tagged-brand-rule',
    ],
);

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
response = client.save_rule(
    index_name="ALGOLIA_INDEX_NAME",
    object_id="tagged-brand-rule",
    rule={
        "conditions": [
            {
                "pattern": "brand: {facet:brand}",
                "anchoring": "contains",
                "alternatives": False,
            },
        ],
        "consequence": {
            "params": {
                "automaticFacetFilters": [
                    {
                        "facet": "brand",
                    },
                ],
                "query": {
                    "remove": [
                        "brand:",
                        "{facet:brand}",
                    ],
                },
            },
        },
        "description": "filter on brand: {brand}",
        "objectID": "tagged-brand-rule",
    },
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
response = client.save_rule(
  "ALGOLIA_INDEX_NAME",
  "tagged-brand-rule",
  Algolia::Search::Rule.new(
    conditions: [
      Algolia::Search::Condition.new(pattern: "brand: {facet:brand}", anchoring: "contains", alternatives: false)
    ],
    consequence: Algolia::Search::Consequence.new(
      params: Algolia::Search::ConsequenceParams.new(
        automatic_facet_filters: [Algolia::Search::AutomaticFacetFilter.new(facet: "brand")],
        query: Algolia::Search::ConsequenceQueryObject.new(remove: ["brand:", "{facet:brand}"])
      )
    ),
    description: "filter on brand: {brand}",
    algolia_object_id: "tagged-brand-rule"
  )
)

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
val response = Await.result(
  client.saveRule(
    indexName = "ALGOLIA_INDEX_NAME",
    objectID = "tagged-brand-rule",
    rule = Rule(
      conditions = Some(
        Seq(
          Condition(
            pattern = Some("brand: {facet:brand}"),
            anchoring = Some(Anchoring.withName("contains")),
            alternatives = Some(false)
          )
        )
      ),
      consequence = Consequence(
        params = Some(
          ConsequenceParams(
            automaticFacetFilters = Some(
              AutomaticFacetFilters(
                Seq(
                  AutomaticFacetFilter(
                    facet = "brand"
                  )
                )
              )
            ),
            query = Some(
              ConsequenceQueryObject(
                remove = Some(Seq("brand:", "{facet:brand}"))
              )
            )
          )
        )
      ),
      description = Some("filter on brand: {brand}"),
      objectID = "tagged-brand-rule"
    )
  ),
  Duration(100, "sec")
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
let response = try await client.saveRule(
    indexName: "ALGOLIA_INDEX_NAME",
    objectID: "tagged-brand-rule",
    rule: Rule(
        objectID: "tagged-brand-rule",
        conditions: [SearchCondition(
            pattern: "brand: {facet:brand}",
            anchoring: SearchAnchoring.contains,
            alternatives: false
        )],
        consequence: SearchConsequence(params: SearchConsequenceParams(
            query: SearchConsequenceQuery.searchConsequenceQueryObject(SearchConsequenceQueryObject(remove: [
                "brand:",
                "{facet:brand}",
            ])),
            automaticFacetFilters: SearchAutomaticFacetFilters
                .arrayOfSearchAutomaticFacetFilter([SearchAutomaticFacetFilter(facet: "brand")])
        )),
        description: "filter on brand: {brand}"
    )
)

Example dataset

All the examples on this page use a product catalog index. The appropriate attributes have been set as attributes for faceting. The index has records that look like this:

Copy
[
    {
      "product_name": "FM",
      "product_type": "T-shirt",
      "brand": "LondonLook",
      "color": "Red",
      "price": 21.99
    },
    {
      "product_name": "Caveman",
      "product_type": "T-shirt",
      "brand": "Red or Dead",
      "color": "Brown",
      "price": 9.99
    },
    {
      "product_name": "iPhone 13 Pro Max",
      "product_type": "Phone",
      "brand": "Apple",
      "color": "Blue",
      "price": 1824.61
    },
    {
      "product_name": "Will Carpenter",
      "product_type": "T-shirt",
      "brand": "Red or Dead",
      "color": "Black",
      "price": 199.99
    },
    {
      "product_name": "The Mandal 800w",
      "product_type": "Toaster",
      "brand": "Black & Decker",
      "color": "Red",
      "price": 149.99
    },
    {
      "product_name": "Essentials 800w",
      "product_type": "Toaster",
      "brand": "Daewoo",
      "color": "Black",
      "price": 14.99
    },
    {
      "product_name": "Airpods Max",
      "product_type": "Headphones",
      "brand": "Apple",
      "color": "Gray",
      "price": 548.99
    },
    {
      "product_name": "WH-CH520",
      "product_type": "Headphones",
      "brand": "Sony",
      "color": "Apple",
      "price": 39.99
    }
]

Dynamic filtering with Rules

On this page

How to create a dynamic filtering rule

Using the dashboard

Using the API

Examples

One rule per facet

Using the dashboard

Using the API

Numerical dynamic filtering

Using the dashboard

Using the API

Tagged filters

Using the dashboard

Using the API

Example dataset

See also

On this page