Return multiple result sets with multifeed compositions

Multifeed compositions are available to selected users. To request access, contact your Algolia customer success manager.

Use multifeed compositions to return several independent result sets from a single API request. Each result set, called a , can have its own search parameters, filters, and Smart Groups. Use multifeed compositions to build federated search experiences. These experiences blend results from different categories, brands, or content types in a single response.

Use cases

Use multifeed compositions when you need to return several independently ranked result sets for the same query in a single request.

Federated search across categories

Show results from different product categories in parallel. For example, when users search for “running”, return separate feeds for running shoes, running apparel, and running accessories. Each feed maintains its own ranking strategy, filters, and promoted items. This way, category-specific merchandising doesn’t interfere with other results.

Multi-brand or multi-tenant results

Return results grouped by brand, seller, or tenant in a single response. For example, a marketplace can display products from different sellers. Each seller controls their own promoted items and positioning.

Content type segmentation

Separate results by content type, such as products, articles, or videos, while using the same user query. Each feed applies ranking and filtering tailored to its content type. For example, products may focus on conversion signals, while articles focus on recency or engagement.

How multifeed works

A multifeed composition defines several feeds in the behavior.multifeed object. Each feed:

Has a unique identifier (feedID)
Contains its own behavior, typically an injection with search parameters and Smart Groups
Returns an independent result set in the response

All feeds run in parallel, sharing the same base query unless you override parameters for a feed at run time. Each feed is standalone, with its own Smart Groups injected into its .

Define a multifeed composition

Use the Composition API to create a multifeed composition. The following example creates a composition that returns three separate feeds for different content types: products, articles, and videos.

var response = await client.PutCompositionAsync(
  "my-external-provider-compo",
  new Composition
  {
    ObjectID = "my-external-provider-compo",
    Name = "my external provider composition",
    Behavior = new CompositionBehavior(
      new CompositionInjectionBehavior
      {
        Injection = new Injection
        {
          Main = new InjectionMain
          {
            Source = new InjectionMainSource(
              new InjectionMainExternalProviderSource
              {
                ExternalProvider = new InjectionMainExternalProvider
                {
                  Index = "products",
                  ConfigurationID = "my-rmn-connection",
                  ConfigurationParams = new Dictionary<string, object>
                  {
                    { "campaign_id", "summer-sale" },
                    { "customer_id", "customer-default" },
                  },
                  Params = new MainInjectionQueryParameters { Filters = "instock:true" },
                  Ordering = Enum.Parse<ExternalProviderOrdering>("ProviderDefined"),
                },
              }
            ),
          },
          InjectedItems = new List<InjectionInjectedItem>
          {
            new InjectionInjectedItem
            {
              Key = "sponsored",
              Source = new InjectedItemSource(
                new InjectedItemExternalProviderSource
                {
                  ExternalProvider = new InjectedItemExternalProvider
                  {
                    Index = "products",
                    ConfigurationID = "my-rmn-connection",
                    ConfigurationParams = new Dictionary<string, object>
                    {
                      { "campaign_id", "summer-sale" },
                    },
                  },
                }
              ),
              Position = 0,
              Length = 2,
            },
          },
        },
      }
    ),
  }
);

final response = await client.putComposition(
  compositionID: "my-external-provider-compo",
  composition: Composition(
    objectID: "my-external-provider-compo",
    name: "my external provider composition",
    behavior: CompositionInjectionBehavior(
      injection: Injection(
        main: InjectionMain(
          source: InjectionMainExternalProviderSource(
            externalProvider: InjectionMainExternalProvider(
              index: "products",
              configurationID: "my-rmn-connection",
              configurationParams: {
                'campaign_id': "summer-sale",
                'customer_id': "customer-default",
              },
              params: MainInjectionQueryParameters(
                filters: "instock:true",
              ),
              ordering: ExternalProviderOrdering.fromJson("providerDefined"),
            ),
          ),
        ),
        injectedItems: [
          InjectionInjectedItem(
            key: "sponsored",
            source: InjectedItemExternalProviderSource(
              externalProvider: InjectedItemExternalProvider(
                index: "products",
                configurationID: "my-rmn-connection",
                configurationParams: {
                  'campaign_id': "summer-sale",
                },
              ),
            ),
            position: 0,
            length: 2,
          ),
        ],
      ),
    ),
  ),
);

response, err := client.PutComposition(client.NewApiPutCompositionRequest(
  "my-external-provider-compo",
  composition.NewEmptyComposition().
    SetObjectID("my-external-provider-compo").
    SetName("my external provider composition").
    SetBehavior(composition.CompositionInjectionBehaviorAsCompositionBehavior(
      composition.NewEmptyCompositionInjectionBehavior().SetInjection(
        composition.NewEmptyInjection().SetMain(
          composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainExternalProviderSourceAsInjectionMainSource(
            composition.NewEmptyInjectionMainExternalProviderSource().SetExternalProvider(
              composition.NewEmptyInjectionMainExternalProvider().
                SetIndex("products").
                SetConfigurationID("my-rmn-connection").
                SetConfigurationParams(map[string]any{"campaign_id": "summer-sale", "customer_id": "customer-default"}).
                SetParams(
                  composition.NewEmptyMainInjectionQueryParameters().
                    SetFilters("instock:true"),
                ).
                SetOrdering(composition.ExternalProviderOrdering("providerDefined")),
            ),
          ))).SetInjectedItems(
          []composition.InjectionInjectedItem{
            *composition.NewEmptyInjectionInjectedItem().SetKey("sponsored").SetSource(composition.InjectedItemExternalProviderSourceAsInjectedItemSource(
              composition.NewEmptyInjectedItemExternalProviderSource().SetExternalProvider(
                composition.NewEmptyInjectedItemExternalProvider().SetIndex("products").SetConfigurationID("my-rmn-connection").SetConfigurationParams(map[string]any{"campaign_id": "summer-sale"})))).SetPosition(0).SetLength(2),
          }),
      ))),
))
if err != nil {
  // handle the eventual error
  panic(err)
}

TaskIDResponse response = client.putComposition(
  "my-external-provider-compo",
  new Composition()
    .setObjectID("my-external-provider-compo")
    .setName("my external provider composition")
    .setBehavior(
      new CompositionInjectionBehavior().setInjection(
        new Injection()
          .setMain(
            new InjectionMain().setSource(
              new InjectionMainExternalProviderSource().setExternalProvider(
                new InjectionMainExternalProvider()
                  .setIndex("products")
                  .setConfigurationID("my-rmn-connection")
                  .setConfigurationParams(
                    new HashMap() {
                      {
                        put("campaign_id", "summer-sale");
                        put("customer_id", "customer-default");
                      }
                    }
                  )
                  .setParams(new MainInjectionQueryParameters().setFilters("instock:true"))
                  .setOrdering(ExternalProviderOrdering.PROVIDER_DEFINED)
              )
            )
          )
          .setInjectedItems(
            Arrays.asList(
              new InjectionInjectedItem()
                .setKey("sponsored")
                .setSource(
                  new InjectedItemExternalProviderSource().setExternalProvider(
                    new InjectedItemExternalProvider()
                      .setIndex("products")
                      .setConfigurationID("my-rmn-connection")
                      .setConfigurationParams(
                        new HashMap() {
                          {
                            put("campaign_id", "summer-sale");
                          }
                        }
                      )
                  )
                )
                .setPosition(0)
                .setLength(2)
            )
          )
      )
    )
);

const response = await client.putComposition({
  compositionID: 'my-external-provider-compo',
  composition: {
    objectID: 'my-external-provider-compo',
    name: 'my external provider composition',
    behavior: {
      injection: {
        main: {
          source: {
            externalProvider: {
              index: 'products',
              configurationID: 'my-rmn-connection',
              configurationParams: { campaign_id: 'summer-sale', customer_id: 'customer-default' },
              params: { filters: 'instock:true' },
              ordering: 'providerDefined',
            },
          },
        },
        injectedItems: [
          {
            key: 'sponsored',
            source: {
              externalProvider: {
                index: 'products',
                configurationID: 'my-rmn-connection',
                configurationParams: { campaign_id: 'summer-sale' },
              },
            },
            position: 0,
            length: 2,
          },
        ],
      },
    },
  },
});

var response =
  client.putComposition(
    compositionID = "my-external-provider-compo",
    composition =
      Composition(
        objectID = "my-external-provider-compo",
        name = "my external provider composition",
        behavior =
          CompositionInjectionBehavior(
            injection =
              Injection(
                main =
                  InjectionMain(
                    source =
                      InjectionMainExternalProviderSource(
                        externalProvider =
                          InjectionMainExternalProvider(
                            index = "products",
                            configurationID = "my-rmn-connection",
                            configurationParams =
                              buildJsonObject {
                                put("campaign_id", JsonPrimitive("summer-sale"))
                                put("customer_id", JsonPrimitive("customer-default"))
                              },
                            params = MainInjectionQueryParameters(filters = "instock:true"),
                            ordering =
                              ExternalProviderOrdering.entries.first {
                                it.value == "providerDefined"
                              },
                          )
                      )
                  ),
                injectedItems =
                  listOf(
                    InjectionInjectedItem(
                      key = "sponsored",
                      source =
                        InjectedItemExternalProviderSource(
                          externalProvider =
                            InjectedItemExternalProvider(
                              index = "products",
                              configurationID = "my-rmn-connection",
                              configurationParams =
                                buildJsonObject {
                                  put("campaign_id", JsonPrimitive("summer-sale"))
                                },
                            )
                        ),
                      position = 0,
                      length = 2,
                    )
                  ),
              )
          ),
      ),
  )

$response = $client->putComposition(
    'my-external-provider-compo',
    ['objectID' => 'my-external-provider-compo',
        'name' => 'my external provider composition',
        'behavior' => ['injection' => ['main' => ['source' => ['externalProvider' => ['index' => 'products',
            'configurationID' => 'my-rmn-connection',
            'configurationParams' => ['campaign_id' => 'summer-sale',
                'customer_id' => 'customer-default',
            ],
            'params' => ['filters' => 'instock:true',
            ],
            'ordering' => 'providerDefined',
        ],
        ],
        ],
            'injectedItems' => [
                ['key' => 'sponsored',
                    'source' => ['externalProvider' => ['index' => 'products',
                        'configurationID' => 'my-rmn-connection',
                        'configurationParams' => ['campaign_id' => 'summer-sale',
                        ],
                    ],
                    ],
                    'position' => 0,
                    'length' => 2,
                ],
            ],
        ],
        ],
    ],
);

response = client.put_composition(
    composition_id="my-external-provider-compo",
    composition={
        "objectID": "my-external-provider-compo",
        "name": "my external provider composition",
        "behavior": {
            "injection": {
                "main": {
                    "source": {
                        "externalProvider": {
                            "index": "products",
                            "configurationID": "my-rmn-connection",
                            "configurationParams": {
                                "campaign_id": "summer-sale",
                                "customer_id": "customer-default",
                            },
                            "params": {
                                "filters": "instock:true",
                            },
                            "ordering": "providerDefined",
                        },
                    },
                },
                "injectedItems": [
                    {
                        "key": "sponsored",
                        "source": {
                            "externalProvider": {
                                "index": "products",
                                "configurationID": "my-rmn-connection",
                                "configurationParams": {
                                    "campaign_id": "summer-sale",
                                },
                            },
                        },
                        "position": 0,
                        "length": 2,
                    },
                ],
            },
        },
    },
)

response = client.put_composition(
  "my-external-provider-compo",
  Algolia::Composition::Composition.new(
    algolia_object_id: "my-external-provider-compo",
    name: "my external provider composition",
    behavior: Algolia::Composition::CompositionInjectionBehavior.new(
      injection: Algolia::Composition::Injection.new(
        main: Algolia::Composition::InjectionMain.new(
          source: Algolia::Composition::InjectionMainExternalProviderSource.new(
            external_provider: Algolia::Composition::InjectionMainExternalProvider.new(
              index: "products",
              configuration_id: "my-rmn-connection",
              configuration_params: {campaign_id: "summer-sale", customer_id: "customer-default"},
              params: Algolia::Composition::MainInjectionQueryParameters.new(filters: "instock:true"),
              ordering: "providerDefined"
            )
          )
        ),
        injected_items: [
          Algolia::Composition::InjectionInjectedItem.new(
            key: "sponsored",
            source: Algolia::Composition::InjectedItemExternalProviderSource.new(
              external_provider: Algolia::Composition::InjectedItemExternalProvider.new(
                index: "products",
                configuration_id: "my-rmn-connection",
                configuration_params: {campaign_id: "summer-sale"}
              )
            ),
            position: 0,
            length: 2
          )
        ]
      )
    )
  )
)

val response = Await.result(
  client.putComposition(
    compositionID = "my-external-provider-compo",
    composition = Composition(
      objectID = "my-external-provider-compo",
      name = "my external provider composition",
      behavior = CompositionInjectionBehavior(
        injection = Injection(
          main = InjectionMain(
            source = Some(
              InjectionMainExternalProviderSource(
                externalProvider = InjectionMainExternalProvider(
                  index = "products",
                  configurationID = "my-rmn-connection",
                  configurationParams =
                    Some(Map("campaign_id" -> "summer-sale", "customer_id" -> "customer-default")),
                  params = Some(
                    MainInjectionQueryParameters(
                      filters = Some("instock:true")
                    )
                  ),
                  ordering = Some(ExternalProviderOrdering.withName("providerDefined"))
                )
              )
            )
          ),
          injectedItems = Some(
            Seq(
              InjectionInjectedItem(
                key = "sponsored",
                source = InjectedItemExternalProviderSource(
                  externalProvider = InjectedItemExternalProvider(
                    index = "products",
                    configurationID = "my-rmn-connection",
                    configurationParams = Some(Map("campaign_id" -> "summer-sale"))
                  )
                ),
                position = 0,
                length = 2
              )
            )
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

let response = try await client.putComposition(
    compositionID: "my-external-provider-compo",
    composition: Composition(
        objectID: "my-external-provider-compo",
        name: "my external provider composition",
        behavior: CompositionBehavior
            .compositionInjectionBehavior(CompositionInjectionBehavior(injection: Injection(
                main: InjectionMain(source: InjectionMainSource
                    .injectionMainExternalProviderSource(
                        InjectionMainExternalProviderSource(externalProvider: InjectionMainExternalProvider(
                            index: "products",
                            configurationID: "my-rmn-connection",
                            configurationParams: [
                                "campaign_id": AnyCodable("summer-sale"),
                                "customer_id": AnyCodable("customer-default"),
                            ],
                            ordering: ExternalProviderOrdering.providerDefined,
                            params: MainInjectionQueryParameters(filters: "instock:true")
                        ))
                    )),
                injectedItems: [InjectionInjectedItem(
                    key: "sponsored",
                    source: InjectedItemSource
                        .injectedItemExternalProviderSource(
                            InjectedItemExternalProviderSource(externalProvider: InjectedItemExternalProvider(
                                index: "products",
                                configurationID: "my-rmn-connection",
                                configurationParams: ["campaign_id": AnyCodable("summer-sale")]
                            ))
                        ),
                    position: 0,
                    length: 2
                )]
            )))
    )
)

Key parameters

feeds: A map of feed definitions, where each key is the feed ID and each value is a behavior, typically an injection
feedsOrder (optional): An array specifying the order feeds appear in the response. If omitted, feeds return in alphabetical order by feed ID

Query a multifeed composition

Query a multifeed composition the same way as a standard composition using the Run a Composition endpoint. Use the optional feedsOrder parameter to reorder, enable, or turn feeds off at run time. This overrides the value defined in the composition itself.

var response = await client.SearchAsync<Hit>(
  "foo",
  new RequestBody
  {
    Params = new Params { Query = "shoes", Filters = "brand:acme" },
    Feeds = new Dictionary<string, FeedRequest>
    {
      {
        "organic",
        new FeedRequest
        {
          Params = new FeedParams
          {
            Filters = "brand:acme AND inStock:true",
            SortBy = "Price (asc)",
          },
        }
      },
      {
        "banner",
        new FeedRequest
        {
          Params = new FeedParams { Query = "shoes sale", Filters = "" },
        }
      },
    },
    FeedsOrder = new List<string> { "banner", "organic" },
  }
);

final response = await client.search(
  compositionID: "foo",
  requestBody: RequestBody(
    params: Params(
      query: "shoes",
      filters: "brand:acme",
    ),
    feeds: {
      'organic': FeedRequest(
        params: FeedParams(
          filters: "brand:acme AND inStock:true",
          sortBy: "Price (asc)",
        ),
      ),
      'banner': FeedRequest(
        params: FeedParams(
          query: "shoes sale",
          filters: "",
        ),
      ),
    },
    feedsOrder: [
      "banner",
      "organic",
    ],
  ),
);

response, err := client.Search(client.NewApiSearchRequest(
  "foo",
  composition.NewEmptyRequestBody().SetParams(
    composition.NewEmptyParams().
      SetQuery("shoes").
      SetFilters("brand:acme"),
  ).
    SetFeeds(map[string]composition.FeedRequest{"organic": *composition.NewEmptyFeedRequest().SetParams(
      composition.NewEmptyFeedParams().SetFilters("brand:acme AND inStock:true").SetSortBy("Price (asc)")), "banner": *composition.NewEmptyFeedRequest().SetParams(
      composition.NewEmptyFeedParams().SetQuery("shoes sale").SetFilters(""))}).SetFeedsOrder(
    []string{"banner", "organic"})))
if err != nil {
  // handle the eventual error
  panic(err)
}

SearchResponse response = client.search(
  "foo",
  new RequestBody()
    .setParams(new Params().setQuery("shoes").setFilters("brand:acme"))
    .setFeeds(
      new HashMap() {
        {
          put(
            "organic",
            new FeedRequest().setParams(new FeedParams().setFilters("brand:acme AND inStock:true").setSortBy("Price (asc)"))
          );
          put("banner", new FeedRequest().setParams(new FeedParams().setQuery("shoes sale").setFilters("")));
        }
      }
    )
    .setFeedsOrder(Arrays.asList("banner", "organic")),
  Hit.class
);

const response = await client.search({
  compositionID: 'foo',
  requestBody: {
    params: { query: 'shoes', filters: 'brand:acme' },
    feeds: {
      organic: { params: { filters: 'brand:acme AND inStock:true', sortBy: 'Price (asc)' } },
      banner: { params: { query: 'shoes sale', filters: '' } },
    },
    feedsOrder: ['banner', 'organic'],
  },
});

var response =
  client.search(
    compositionID = "foo",
    requestBody =
      RequestBody(
        params = Params(query = "shoes", filters = "brand:acme"),
        feeds =
          mapOf(
            "organic" to
              FeedRequest(
                params =
                  FeedParams(filters = "brand:acme AND inStock:true", sortBy = "Price (asc)")
              ),
            "banner" to FeedRequest(params = FeedParams(query = "shoes sale", filters = "")),
          ),
        feedsOrder = listOf("banner", "organic"),
      ),
  )

$response = $client->search(
    'foo',
    ['params' => ['query' => 'shoes',
        'filters' => 'brand:acme',
    ],
        'feeds' => ['organic' => ['params' => ['filters' => 'brand:acme AND inStock:true',
            'sortBy' => 'Price (asc)',
        ],
        ],
            'banner' => ['params' => ['query' => 'shoes sale',
                'filters' => '',
            ],
            ],
        ],
        'feedsOrder' => [
            'banner',

            'organic',
        ],
    ],
);

response = client.search(
    composition_id="foo",
    request_body={
        "params": {
            "query": "shoes",
            "filters": "brand:acme",
        },
        "feeds": {
            "organic": {
                "params": {
                    "filters": "brand:acme AND inStock:true",
                    "sortBy": "Price (asc)",
                },
            },
            "banner": {
                "params": {
                    "query": "shoes sale",
                    "filters": "",
                },
            },
        },
        "feedsOrder": [
            "banner",
            "organic",
        ],
    },
)

response = client.search(
  "foo",
  Algolia::Composition::RequestBody.new(
    params: Algolia::Composition::Params.new(query: "shoes", filters: "brand:acme"),
    feeds: {
      organic: Algolia::Composition::FeedRequest.new(
        params: Algolia::Composition::FeedParams.new(filters: "brand:acme AND inStock:true", sort_by: "Price (asc)")
      ),
      banner: Algolia::Composition::FeedRequest.new(
        params: Algolia::Composition::FeedParams.new(query: "shoes sale", filters: "")
      )
    },
    feeds_order: ["banner", "organic"]
  )
)

val response = Await.result(
  client.search(
    compositionID = "foo",
    requestBody = RequestBody(
      params = Some(
        Params(
          query = Some("shoes"),
          filters = Some("brand:acme")
        )
      ),
      feeds = Some(
        Map(
          "organic" -> FeedRequest(
            params = Some(
              FeedParams(
                filters = Some("brand:acme AND inStock:true"),
                sortBy = Some("Price (asc)")
              )
            )
          ),
          "banner" -> FeedRequest(
            params = Some(
              FeedParams(
                query = Some("shoes sale"),
                filters = Some("")
              )
            )
          )
        )
      ),
      feedsOrder = Some(Seq("banner", "organic"))
    )
  ),
  Duration(100, "sec")
)

let response: CompositionSearchResponse<CompositionHit> = try await client.search(
    compositionID: "foo",
    requestBody: RequestBody(
        params: CompositionParams(filters: "brand:acme", query: "shoes"),
        feedsOrder: ["banner", "organic"],
        feeds: [
            "organic": FeedRequest(params: FeedParams(
                filters: "brand:acme AND inStock:true",
                sortBy: "Price (asc)"
            )),
            "banner": FeedRequest(params: FeedParams(filters: "", query: "shoes sale")),
        ]
    )
)

The response includes one result set per feed. Algolia orders the feeds based on the feedsOrder value. Each feed’s result set includes the corresponding feedID and Smart Groups injected into its . Deduplication applies within that feed.

JSON

{
  "results": [
    {
      "feedID": "products",
      "hits": [
        {
          "objectID": "prod-123",
          "title": "Professional Camera",
          "featured": true
        },
        {
          "objectID": "prod-456",
          "title": "Camera Lens Kit",
          "featured": true
        },
        { "objectID": "prod-789", "title": "Camera Tripod" },
        { "objectID": "prod-012", "title": "Memory Card" }
      ],
      "nbHits": 87,
      "page": 0,
      "nbPages": 8,
      "hitsPerPage": 12,
      "query": "camera"
    },
    {
      "feedID": "articles",
      "hits": [
        {
          "objectID": "article-111",
          "title": "How to Choose Your First Camera",
          "excerpt": "A beginner's guide...",
          "editorial_pick": true
        },
        {
          "objectID": "article-222",
          "title": "Camera Settings Guide",
          "excerpt": "Master exposure..."
        },
        {
          "objectID": "article-333",
          "title": "Camera Maintenance Tips",
          "excerpt": "Keep your equipment..."
        }
      ],
      "nbHits": 24,
      "page": 0,
      "nbPages": 5,
      "hitsPerPage": 5,
      "query": "camera"
    },
    {
      "feedID": "videos",
      "hits": [
        {
          "objectID": "video-555",
          "title": "Camera Setup Tutorial",
          "duration": 420
        },
        {
          "objectID": "video-666",
          "title": "Product Review: Latest Camera",
          "duration": 615
        }
      ],
      "nbHits": 15,
      "page": 0,
      "nbPages": 5,
      "hitsPerPage": 3,
      "query": "camera"
    }
  ]
}

Algolia processes each feed in a multifeed composition independently, as a complete result set. This means:

Deduplication applies within each feed according to your deduplication strategy. This prevents duplicate items between Smart Groups and in that feed
Facet values are computed based on each feed’s configuration and results
Pagination works independently for each feed

Items can appear in more than one feed if they match the criteria for different feeds. For example, the same product could appear in both a “featured products” feed and a “new arrivals” feed.

Set parameters per feed

By default, every feed uses the params from the request. To change parameters for individual feeds, such as filters, query, hitsPerPage, or sortBy, add a feeds object to the Run a Composition request. Each property is a feed ID, and its value contains a params object. In the following example, the organic feed adds an in-stock filter and sorts by price. The banner feed uses a different query and removes the root filter.

JSON

{
  "params": {
    "query": "shoes",
    "filters": "brand:acme"
  },
  "feeds": {
    "organic": {
      "params": {
        "filters": "brand:acme AND inStock:true",
        "sortBy": "Price (asc)"
      }
    },
    "banner": {
      "params": {
        "query": "shoes sale",
        "filters": ""
      }
    }
  },
  "feedsOrder": ["banner", "organic"]
}

A feed inherits every root parameter that it doesn’t set.
A feed value replaces the root value instead of combining with it. This applies to every parameter, including filters, facetFilters, optionalFilters, and analyticsTags. To keep the root filters, repeat them in the feed’s params, as the organic feed does in the previous example.
An empty value, such as "filters": "", discards the root value for that feed.
Feed params accept the same parameters as the root params, except injectedItems, getRankingInfo, and enableABTest. An unsupported feed parameter return a 400 error.
If a feed ID doesn’t exist in the composition, for example because a rule removed it, the response reports it in the errors field and the request still succeeds.
Rules match once per request, against the root params only. A query or sortBy set only on a feed doesn’t trigger rules or Smart Groups.

To sort feeds independently, see Sort multifeed compositions.

Integrate with InstantSearch

Before integrating multifeed compositions with InstantSearch, make sure you’ve completed the base composition setup. This includes installing the Composition API client and configuring your compositionID. Multifeed support requires these versions of the InstantSearch libraries:

React InstantSearch: version 7.32.0 or later
InstantSearch.js: version 4.96.0 or later
Vue InstantSearch: version 4.26.0 or later

Use the Feeds widget to render each feed from a multifeed composition as an independent result set. Each feed gets its own widget scope, so widgets like Hits or RefinementList inside a feed only see that feed’s results.

import { Feeds, Hits, Highlight } from "react-instantsearch";

function Search() {
  return (
    <Feeds
      searchScope="global"
      renderFeed={({ feedID }) => (
        <section>
          <h2>{feedID}</h2>
          {feedID === "products" ? (
            <Hits
              hitComponent={({ hit }) => (
                <article>
                  <Highlight attribute="name" hit={hit} />
                  <p>{hit.price}</p>
                </article>
              )}
            />
          ) : (
            <Hits
              hitComponent={({ hit }) => (
                <article>
                  <Highlight attribute="title" hit={hit} />
                  <p>{hit.excerpt}</p>
                </article>
              )}
            />
          )}
        </section>
      )}
    />
  );
}

import { feeds, hits } from "instantsearch.js/es/widgets";

const feedsWidget = feeds({
  container: "#feeds",
  searchScope: "global",
  widgets: (container, feedID) => {
    if (feedID === "products") {
      return [
        hits({
          container,
          templates: {
            item(hit, { html, components }) {
              return html`
                <article>
                  <h3>${components.Highlight({ hit, attribute: "name" })}</h3>
                  <p>${hit.price}</p>
                </article>
              `;
            },
          },
        }),
      ];
    }

    return [
      hits({
        container,
        templates: {
          item(hit, { html, components }) {
            return html`
              <article>
                <h3>${components.Highlight({ hit, attribute: "title" })}</h3>
                <p>${hit.excerpt}</p>
              </article>
            `;
          },
        },
      }),
    ];
  },
});

<template>
  <ais-feeds search-scope="global">
    <template v-slot="{ feedID }">
      <section>
        <h2>{{ feedID }}</h2>

        <ais-hits v-if="feedID === 'products'">
          <template v-slot:item="{ item }">
            <article>
              <ais-highlight attribute="name" :hit="item" />
              <p>{{ item.price }}</p>
            </article>
          </template>
        </ais-hits>

        <ais-hits v-else>
          <template v-slot:item="{ item }">
            <article>
              <ais-highlight attribute="title" :hit="item" />
              <p>{{ item.excerpt }}</p>
            </article>
          </template>
        </ais-hits>
      </section>
    </template>
  </ais-feeds>
</template>

`useFeeds` Hook (React)

The useFeeds Hook gives you direct access to the list of feed IDs without rendering feeds. This is useful for building custom UI around feeds, such as tab navigation or feed counts.

React

import { useFeeds, Feeds } from "react-instantsearch";

function TabbedFeeds() {
  const { feedIDs } = useFeeds({ searchScope: "global" });
  const [activeTab, setActiveTab] = useState(feedIDs[0]);

  return (
    <>
      <nav>
        {feedIDs.map((id) => (
          <button key={id} onClick={() => setActiveTab(id)}>
            {id}
          </button>
        ))}
      </nav>
      <Feeds
        searchScope="global"
        renderFeed={({ feedID }) => (
          <div style={{ display: feedID === activeTab ? "block" : "none" }}>
            <Hits />
          </div>
        )}
      />
    </>
  );
}

Transform feeds

All three InstantSearch flavors accept a transformFeeds option that lets you reorder or filter feeds on the client side. The function receives an array of feed IDs and returns a new array.

React

<Feeds
  searchScope="global"
  transformFeeds={(feedIDs) => feedIDs.filter((id) => id !== "internal")}
  renderFeed={({ feedID }) => (
    <section>
      <Hits />
    </section>
  )}
/>

Limits and considerations

You can apply sorting strategies to all feeds or to individual feeds
Feeds share the same base and parameters from the request, unless you set parameters per feed
Pagination applies independently to each feed

Search and Discovery platform

Optimization and Personalization

AI-powered experiences

Production and scale

Return multiple result sets with multifeed compositions

Use cases

Federated search across categories

Multi-brand or multi-tenant results

Content type segmentation

How multifeed works

Define a multifeed composition

Key parameters

Query a multifeed composition

Deduplication and facet management

Set parameters per feed

Integrate with InstantSearch

`useFeeds` Hook (React)

Transform feeds

Limits and considerations

​Use cases

​Federated search across categories

​Multi-brand or multi-tenant results

​Content type segmentation

​How multifeed works

​Define a multifeed composition

​Key parameters

​Query a multifeed composition

​Deduplication and facet management

​Set parameters per feed

​Integrate with InstantSearch

​useFeeds Hook (React)

​Transform feeds

​Limits and considerations

Use cases

Federated search across categories

Multi-brand or multi-tenant results

Content type segmentation

How multifeed works

Define a multifeed composition

Key parameters

Query a multifeed composition

Deduplication and facet management

Set parameters per feed

Integrate with InstantSearch

`useFeeds` Hook (React)

Transform feeds

Limits and considerations