renderingContent

Configuration for rendering the search interface

The renderingContent parameter defines how your search results and facets are ordered in the user interface.

This configuration is primarily used by InstantSearch to control widget behavior, display banners, and sort or hide facets. You can set a default using setSettings and override it dynamically with Rules.

Usage

• Use with InstantSearch widgets like dynamicWidgets, Hits, or InfiniteHits.
• If you’re not using InstantSearch, you can manually build a UI with renderingContent.
• This property has a 2 MB limit. Exceeding this size causes errors.

Properties

facetOrdering · object

Controls how facets and their values are ordered in the UI.

Show child attributes

facetOrdering.facets · object

Show child attributes

facets.order · list<string>

List of facet names in the desired display order.

facetOrdering.values · object

Customizes the behavior of individual facet values.

Show child attributes

<facetName>.hide · list<string>

List of facet values to hide from the UI.

<facetName>.order · list<string>

Explicit order for specific facet values.

<facetName>.sortRemainingBy · enum<string>

How to sort facet values not listed in order.

• count. Sort by decreasing facet value count.
• alpha. Sort alphabetically.
• hidden. Hide any unlisted values.

redirect · object

Show child attributes

redirect.url · string

Target URL for a rule-based redirect.

widgets · object

Custom widget configuration returned from active rules.

Show child attributes

widgets.banners · list<object>

Custom data for rendering banners defined in the Merchandising Studio.

Usage

InstantSearch uses this property to define the UI through configuration—for example, with the dynamicWidgets widget.

If you’re not using InstantSearch for your frontend, you can build a UI with renderingContent

Example

The following example snippet uses renderingContent to define how results are displayed:

• In dynamic widgets, size is always shown before brand.
• For the brand facet: the facet value uniqlo is always shown first, muji is never shown, and other facet values are sorted by decreasing facet count.
• For the size facet: only the values S, M, and L are shown and other facet values are hidden.

Current API clients

C#

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings
  {
    RenderingContent = new RenderingContent
    {
      FacetOrdering = new FacetOrdering
      {
        Facets = new Facets
        {
          Order = new List<string> { "size", "brand" },
        },
        Values = new Dictionary<string, Value>
        {
          {
            "brand",
            new Value
            {
              Order = new List<string> { "uniqlo" },
              Hide = new List<string> { "muji" },
              SortRemainingBy = Enum.Parse<SortRemainingBy>("Count"),
            }
          },
          {
            "size",
            new Value
            {
              Order = new List<string> { "S", "M", "L" },
              SortRemainingBy = Enum.Parse<SortRemainingBy>("Hidden"),
            }
          },
        },
      },
    },
  }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    renderingContent: RenderingContent(
      facetOrdering: FacetOrdering(
        facets: Facets(
          order: [
            "size",
            "brand",
          ],
        ),
        values: {
          'brand': Value(
            order: [
              "uniqlo",
            ],
            hide: [
              "muji",
            ],
            sortRemainingBy: SortRemainingBy.fromJson("count"),
          ),
          'size': Value(
            order: [
              "S",
              "M",
              "L",
            ],
            sortRemainingBy: SortRemainingBy.fromJson("hidden"),
          ),
        },
      ),
    ),
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetRenderingContent(
    search.NewEmptyRenderingContent().SetFacetOrdering(
      search.NewEmptyFacetOrdering().SetFacets(
        search.NewEmptyFacets().SetOrder(
          []string{"size", "brand"})).SetValues(map[string]search.Value{"brand": *search.NewEmptyValue().SetOrder(
        []string{"uniqlo"}).SetHide(
        []string{"muji"}).SetSortRemainingBy(search.SortRemainingBy("count")), "size": *search.NewEmptyValue().SetOrder(
        []string{"S", "M", "L"}).SetSortRemainingBy(search.SortRemainingBy("hidden"))})))))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings(
  "INDEX_NAME",
  new IndexSettings().setRenderingContent(
    new RenderingContent().setFacetOrdering(
      new FacetOrdering().setFacets(new Facets().setOrder(Arrays.asList("size", "brand"))).setValues(
        new HashMap() {
          {
            put(
              "brand",
              new Value().setOrder(Arrays.asList("uniqlo")).setHide(Arrays.asList("muji")).setSortRemainingBy(SortRemainingBy.COUNT)
            );
            put("size", new Value().setOrder(Arrays.asList("S", "M", "L")).setSortRemainingBy(SortRemainingBy.HIDDEN));
          }
        }
      )
    )
  )
);

const response = await client.setSettings({
  indexName: 'theIndexName',
  indexSettings: {
    renderingContent: {
      facetOrdering: {
        facets: { order: ['size', 'brand'] },
        values: {
          brand: { order: ['uniqlo'], hide: ['muji'], sortRemainingBy: 'count' },
          size: { order: ['S', 'M', 'L'], sortRemainingBy: 'hidden' },
        },
      },
    },
  },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings =
      IndexSettings(
        renderingContent =
          RenderingContent(
            facetOrdering =
              FacetOrdering(
                facets = Facets(order = listOf("size", "brand")),
                values =
                  mapOf(
                    "brand" to
                      Value(
                        order = listOf("uniqlo"),
                        hide = listOf("muji"),
                        sortRemainingBy = SortRemainingBy.entries.first { it.value == "count" },
                      ),
                    "size" to
                      Value(
                        order = listOf("S", "M", "L"),
                        sortRemainingBy = SortRemainingBy.entries.first { it.value == "hidden" },
                      ),
                  ),
              )
          )
      ),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['renderingContent' => ['facetOrdering' => ['facets' => ['order' => [
        'size',

        'brand',
    ],
    ],
        'values' => ['brand' => ['order' => [
            'uniqlo',
        ],
            'hide' => [
                'muji',
            ],
            'sortRemainingBy' => 'count',
        ],
            'size' => ['order' => [
                'S',

                'M',

                'L',
            ],
                'sortRemainingBy' => 'hidden',
            ],
        ],
    ],
    ],
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "renderingContent": {
            "facetOrdering": {
                "facets": {
                    "order": [
                        "size",
                        "brand",
                    ],
                },
                "values": {
                    "brand": {
                        "order": [
                            "uniqlo",
                        ],
                        "hide": [
                            "muji",
                        ],
                        "sortRemainingBy": "count",
                    },
                    "size": {
                        "order": [
                            "S",
                            "M",
                            "L",
                        ],
                        "sortRemainingBy": "hidden",
                    },
                },
            },
        },
    },
)

response = client.set_settings(
  "INDEX_NAME",
  Algolia::Search::IndexSettings.new(
    rendering_content: Algolia::Search::RenderingContent.new(
      facet_ordering: Algolia::Search::FacetOrdering.new(
        facets: Algolia::Search::Facets.new(order: ["size", "brand"]),
        values: {
          brand: Algolia::Search::Value.new(order: ["uniqlo"], hide: ["muji"], sort_remaining_by: "count"),
          size: Algolia::Search::Value.new(order: ["S", "M", "L"], sort_remaining_by: "hidden")
        }
      )
    )
  )
)

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      renderingContent = Some(
        RenderingContent(
          facetOrdering = Some(
            FacetOrdering(
              facets = Some(
                Facets(
                  order = Some(Seq("size", "brand"))
                )
              ),
              values = Some(
                Map(
                  "brand" -> Value(
                    order = Some(Seq("uniqlo")),
                    hide = Some(Seq("muji")),
                    sortRemainingBy = Some(SortRemainingBy.withName("count"))
                  ),
                  "size" -> Value(
                    order = Some(Seq("S", "M", "L")),
                    sortRemainingBy = Some(SortRemainingBy.withName("hidden"))
                  )
                )
              )
            )
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(renderingContent: SearchRenderingContent(facetOrdering: SearchFacetOrdering(
        facets: SearchFacets(order: ["size", "brand"]),
        values: [
            "brand": SearchValue(
                order: ["uniqlo"],
                sortRemainingBy: SearchSortRemainingBy.count,
                hide: ["muji"]
            ),
            "size": SearchValue(order: ["S", "M", "L"], sortRemainingBy: SearchSortRemainingBy.hidden),
        ]
    )))
)

Legacy API clients

C#

var settings = new IndexSettings
{
  RenderingContent = new RenderingContent
  {
    FacetOrdering = new FacetOrdering
    {
      Facets = new FacetsOrder
      {
        Order = new List { "size", "brand" }
      },
      Values = new Dictionary
      {
        {
          "brand",
          new FacetValuesOrder
          {
            Order = new List { "uniqlo" },
            Hide = new List { "muji" },
            SortRemainingBy = "count"
          }
        },
        {
          "size",
          new FacetValuesOrder
          {
            Order = new List { "S", "M", "L" },
            SortRemainingBy = "hidden"
          }
        }
      }
    }
  }
};

index.SetSettings(settings);

// Asynchronous
await index.SetSettingsAsync(settings);

renderingContent := search.RenderingContent{FacetOrdering: &search.FacetOrdering{
	Facets: &search.FacetsOrder{Order: []string{"size", "brand"}},
	Values: map[string]search.FacetValuesOrder{
		"brand": search.NewFacetValuesOrder([]string{"Uniqlo"}, []string{"Muji"}, search.Count),
		"size":  search.NewFacetValuesOrder([]string{"S", "M", "L"}, search.Hidden),
	},
}}

res, err := index.SetSettings(search.Settings{
	RenderingContent: &renderingContent,
})

FacetsOrder facetsOrder = new FacetsOrder(Arrays.asList("size", "brand"));
Map values = new LinkedHashMap<>();
values.put("brand", new FacetValuesOrder(Collections.singletonList("uniqlo"), Collections.singletonList("muji"), "count"));
values.put("size", new FacetValuesOrder(Arrays.asList("S", "M", "L"), "hidden"));
FacetOrdering facetOrdering = new FacetOrdering(facetsOrder, values);
RenderingContent renderingContent = new RenderingContent(facetOrdering);

// Synchronous
index.setSettings(new IndexSettings().setRenderingContent(renderingContent));
// Asynchronous
index.setSettingsAsync(new IndexSettings().setRenderingContent(renderingContent));

index
  .setSettings({
    renderingContent: {
      facetOrdering: {
        facets: {
          order: ["size", "brand"],
        },
        values: {
          brand: {
            order: ["uniqlo"],
            hide: ["muji"],
            sortRemainingBy: "count",
          },
          size: {
            order: ["S", "M", "L"],
            sortRemainingBy: "hidden",
          },
        },
      },
    },
  })
  .then(() => {
    // done
  });

val facetOrdering = FacetOrdering(
    facets = FacetsOrder(order = listOf("size", "brand")),
    values = mapOf(
        Attribute("brand") to FacetValuesOrder
            order = listOf("uniqlo"),
            hide = listOf("muji"),
            sortRemainingBy = SortRule.Count),
        Attribute("size") to FacetValuesOrder(
            order = listOf("S", "M", "L"),
            sortRemainingBy = SortRule.Hidden
        )
    )
)
val renderingContent = RenderingContent(facetOrdering)
val settings = Settings(renderingContent = renderingContent)
index.setSettings(settings)

$index->setSettings([
  'renderingContent' => [
    'facetOrdering' => [
      'facets' => [
        'order' => ['size', 'brand']
      ],
      'values' => [
        'brand'=> [
          'order' => ['uniqlo'],
          'hide' => ['muji'],
          'sortRemainingBy' => 'count'
        ],
        'size'=> [
          'order' => ['S', 'M', 'L'],
          'sortRemainingBy' => 'hidden'
        ],
      ]
    ]
  ]
]);

index.setSettings(
    {
        renderingContent: {
            facetOrdering: {
                facets: {
                    order: ["size", "brand"],
                    values: {
                        brand: {
                            order: ["uniqlo"],
                            hide: ["muji"],
                            sortRemainingBy: "count",
                        },
                        size: {
                            order: ["S", "M", "L"],
                            sortRemainingBy: "hidden",
                        },
                    },
                },
            },
        },
    }
)

index.set_settings(
  {
    renderingContent: {
      facetOrdering: {
        facets: {
          order: ["size", "brand"]
        },
        values: {
          brand: {
            order: ["uniqlo"],
            hide: ["muji"],
            sortRemainingBy: "count"
          },
          size: {
            order: ["S", "M", "L"],
            sortRemainingBy: "hidden"
          }
        }
      }
    }
  }
)

val facetOrdering = FacetOrdering(
  facets = FacetsOrder(order = Seq("size", "brand")),
  values = Map(
    "brand" -> FacetValuesOrder(
      order = Seq("uniqlo"),
      hide = Seq("muji"),
      sortRemainingBy = Some(SortRule.count)
    ),
    "size" -> FacetValuesOrder(
      order = Seq("S", "M", "L"),
      sortRemainingBy = Some(SortRule.hidden)
    )
  )
)
val renderingContent = RenderingContent(facetOrdering = Some(facetOrdering))
client.execute {
  setSettings of "myIndex" `with` IndexSettings(renderingContent = Some(renderingContent))
}

let facetOrdering = FacetOrdering(facets: FacetsOrder(order: ["size", "brand"]),
                                  values: [
                                   "brand": FacetValuesOrder(
                                      order: ["uniqlo"],
                                      hide: ["muji"],
                                      sortRemainingBy: .count
                                    ),
                                   "size": FacetValuesOrder(
                                      order: ["S", "M", "L"],
                                      sortRemainingBy: .hidden
                                    )
                                  ])

let renderingContent = RenderingContent(facetOrdering: facetOrdering)

let settings = Settings()
  .set(\.renderingContent, to: renderingContent)

index.setSettings(settings) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}