> ## Documentation Index
> Fetch the complete documentation index at: https://algolia.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Return multiple result sets with multifeed compositions

> How to provide a federated search experience with a single composition.

export const SearchQuery = () => <Tooltip tip="The text users enter into a search box. In the Search API, this corresponds to the query parameter. A search query is often used with filters, facets, and other parameters, but these aren't part of the query text itself.">
    search query
  </Tooltip>;

export const Index = () => <Tooltip tip="An Algolia index is a searchable dataset that consists of records and configuration settings. These settings define how the records are searched and ranked.">
    index
  </Tooltip>;

export const Feed = () => <Tooltip tip="Group of items used in a composition. Sources can be search results, recommendations, or external data." href="/doc/guides/compositions/multifeed-compositions" cta="Multifeed compositions">
    feed
  </Tooltip>;

export const organicResultsDefinition = "These are the search results ranked by relevance and your configuration without compositions.";

export const OrganicResults = () => <Tooltip tip={organicResultsDefinition} cta="Smart Groups" href="/doc/guides/managing-results/compositions/smart-groups">
    organic results
  </Tooltip>;

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

Use multifeed compositions to return several independent result sets from a single API request.
Each result set, called a <Feed />, can have its own search parameters, filters, and [Smart Groups](/doc/guides/compositions/smart-groups/smart-groups).

Use multifeed compositions to build federated search experiences that blend results from different categories, brands, or content types in a single response.

## Use cases

Use multifeed compositions when you need to return multiple 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, so 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, where 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 prioritize conversion signals, while articles prioritize recency or engagement.

## How multifeed works

A multifeed composition defines multiple 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 but applying their own filters and injection logic. Each feed is standalone, with its own Smart Groups injected into its <OrganicResults />.

## Define a multifeed composition

Use the [Composition API](/doc/rest-api/composition/put-composition) to create a multifeed composition.

The following example creates a composition that returns three separate feeds for different content types: products, articles, and videos.

<CodeGroup>
  ```cs C# theme={"system"}
  var response = await client.PutCompositionAsync(
    "my-compo",
    new Composition
    {
      ObjectID = "my-compo",
      Name = "my composition",
      Behavior = new CompositionBehavior(
        new CompositionMultifeedBehavior
        {
          Multifeed = new Multifeed
          {
            Feeds = new Dictionary<string, FeedInjection>
            {
              {
                "products",
                new FeedInjection
                {
                  Injection = new Injection
                  {
                    Main = new InjectionMain
                    {
                      Source = new InjectionMainSource(
                        new InjectionMainSearchSource
                        {
                          Search = new MainSearch
                          {
                            Index = "products",
                            Params = new MainInjectionQueryParameters { HitsPerPage = 12 },
                          },
                        }
                      ),
                    },
                    InjectedItems = new List<InjectionInjectedItem>
                    {
                      new InjectionInjectedItem
                      {
                        Key = "featured-products",
                        Source = new InjectedItemSource(
                          new InjectedItemSearchSource
                          {
                            Search = new InjectedItemSearch
                            {
                              Index = "products",
                              Params = new BaseInjectionQueryParameters
                              {
                                Filters = "featured:true",
                              },
                            },
                          }
                        ),
                        Position = 0,
                        Length = 2,
                      },
                    },
                  },
                }
              },
              {
                "articles",
                new FeedInjection
                {
                  Injection = new Injection
                  {
                    Main = new InjectionMain
                    {
                      Source = new InjectionMainSource(
                        new InjectionMainSearchSource
                        {
                          Search = new MainSearch
                          {
                            Index = "articles",
                            Params = new MainInjectionQueryParameters
                            {
                              HitsPerPage = 5,
                              AttributesToRetrieve = new List<string>
                              {
                                "title",
                                "excerpt",
                                "publishedAt",
                              },
                            },
                          },
                        }
                      ),
                    },
                    InjectedItems = new List<InjectionInjectedItem>
                    {
                      new InjectionInjectedItem
                      {
                        Key = "editorial-picks",
                        Source = new InjectedItemSource(
                          new InjectedItemSearchSource
                          {
                            Search = new InjectedItemSearch
                            {
                              Index = "articles",
                              Params = new BaseInjectionQueryParameters
                              {
                                Filters = "editorial_pick:true",
                              },
                            },
                          }
                        ),
                        Position = 0,
                        Length = 1,
                      },
                    },
                  },
                }
              },
              {
                "videos",
                new FeedInjection
                {
                  Injection = new Injection
                  {
                    Main = new InjectionMain
                    {
                      Source = new InjectionMainSource(
                        new InjectionMainSearchSource
                        {
                          Search = new MainSearch
                          {
                            Index = "videos",
                            Params = new MainInjectionQueryParameters
                            {
                              HitsPerPage = 3,
                              AttributesToRetrieve = new List<string>
                              {
                                "title",
                                "thumbnail",
                                "duration",
                              },
                            },
                          },
                        }
                      ),
                    },
                  },
                }
              },
            },
            FeedsOrder = new List<string> { "products", "articles", "videos" },
          },
        }
      ),
    }
  );
  ```

  ```dart Dart theme={"system"}
  final response = await client.putComposition(
    compositionID: "my-compo",
    composition: Composition(
      objectID: "my-compo",
      name: "my composition",
      behavior: CompositionMultifeedBehavior(
        multifeed: Multifeed(
          feeds: {
            'products': FeedInjection(
              injection: Injection(
                main: InjectionMain(
                  source: InjectionMainSearchSource(
                    search: MainSearch(
                      index: "products",
                      params: MainInjectionQueryParameters(
                        hitsPerPage: 12,
                      ),
                    ),
                  ),
                ),
                injectedItems: [
                  InjectionInjectedItem(
                    key: "featured-products",
                    source: InjectedItemSearchSource(
                      search: InjectedItemSearch(
                        index: "products",
                        params: BaseInjectionQueryParameters(
                          filters: "featured:true",
                        ),
                      ),
                    ),
                    position: 0,
                    length: 2,
                  ),
                ],
              ),
            ),
            'articles': FeedInjection(
              injection: Injection(
                main: InjectionMain(
                  source: InjectionMainSearchSource(
                    search: MainSearch(
                      index: "articles",
                      params: MainInjectionQueryParameters(
                        hitsPerPage: 5,
                        attributesToRetrieve: [
                          "title",
                          "excerpt",
                          "publishedAt",
                        ],
                      ),
                    ),
                  ),
                ),
                injectedItems: [
                  InjectionInjectedItem(
                    key: "editorial-picks",
                    source: InjectedItemSearchSource(
                      search: InjectedItemSearch(
                        index: "articles",
                        params: BaseInjectionQueryParameters(
                          filters: "editorial_pick:true",
                        ),
                      ),
                    ),
                    position: 0,
                    length: 1,
                  ),
                ],
              ),
            ),
            'videos': FeedInjection(
              injection: Injection(
                main: InjectionMain(
                  source: InjectionMainSearchSource(
                    search: MainSearch(
                      index: "videos",
                      params: MainInjectionQueryParameters(
                        hitsPerPage: 3,
                        attributesToRetrieve: [
                          "title",
                          "thumbnail",
                          "duration",
                        ],
                      ),
                    ),
                  ),
                ),
              ),
            ),
          },
          feedsOrder: [
            "products",
            "articles",
            "videos",
          ],
        ),
      ),
    ),
  );
  ```

  ```go Go theme={"system"}
  response, err := client.PutComposition(client.NewApiPutCompositionRequest(
    "my-compo",
    composition.NewEmptyComposition().
      SetObjectID("my-compo").
      SetName("my composition").
      SetBehavior(composition.CompositionMultifeedBehaviorAsCompositionBehavior(
        composition.NewEmptyCompositionMultifeedBehavior().SetMultifeed(
          composition.NewEmptyMultifeed().
            SetFeeds(map[string]composition.FeedInjection{"products": *composition.NewEmptyFeedInjection().SetInjection(
              composition.NewEmptyInjection().SetMain(
                composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
                  composition.NewEmptyInjectionMainSearchSource().SetSearch(
                    composition.NewEmptyMainSearch().SetIndex("products").SetParams(
                      composition.NewEmptyMainInjectionQueryParameters().SetHitsPerPage(12)))))).SetInjectedItems(
                []composition.InjectionInjectedItem{*composition.NewEmptyInjectionInjectedItem().SetKey("featured-products").SetSource(composition.InjectedItemSearchSourceAsInjectedItemSource(
                  composition.NewEmptyInjectedItemSearchSource().SetSearch(
                    composition.NewEmptyInjectedItemSearch().SetIndex("products").SetParams(
                      composition.NewEmptyBaseInjectionQueryParameters().SetFilters("featured:true"))))).SetPosition(0).SetLength(2)})), "articles": *composition.NewEmptyFeedInjection().SetInjection(
              composition.NewEmptyInjection().SetMain(
                composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
                  composition.NewEmptyInjectionMainSearchSource().SetSearch(
                    composition.NewEmptyMainSearch().SetIndex("articles").SetParams(
                      composition.NewEmptyMainInjectionQueryParameters().SetHitsPerPage(5).SetAttributesToRetrieve(
                        []string{"title", "excerpt", "publishedAt"})))))).SetInjectedItems(
                []composition.InjectionInjectedItem{*composition.NewEmptyInjectionInjectedItem().SetKey("editorial-picks").SetSource(composition.InjectedItemSearchSourceAsInjectedItemSource(
                  composition.NewEmptyInjectedItemSearchSource().SetSearch(
                    composition.NewEmptyInjectedItemSearch().SetIndex("articles").SetParams(
                      composition.NewEmptyBaseInjectionQueryParameters().SetFilters("editorial_pick:true"))))).SetPosition(0).SetLength(1)})), "videos": *composition.NewEmptyFeedInjection().SetInjection(
              composition.NewEmptyInjection().SetMain(
                composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
                  composition.NewEmptyInjectionMainSearchSource().SetSearch(
                    composition.NewEmptyMainSearch().SetIndex("videos").SetParams(
                      composition.NewEmptyMainInjectionQueryParameters().SetHitsPerPage(3).SetAttributesToRetrieve(
                        []string{"title", "thumbnail", "duration"})))))))}).
            SetFeedsOrder(
              []string{"products", "articles", "videos"}),
        ),
      )),
  ))
  if err != nil {
    // handle the eventual error
    panic(err)
  }
  ```

  ```java Java theme={"system"}
  TaskIDResponse response = client.putComposition(
    "my-compo",
    new Composition()
      .setObjectID("my-compo")
      .setName("my composition")
      .setBehavior(
        new CompositionMultifeedBehavior().setMultifeed(
          new Multifeed()
            .setFeeds(
              new HashMap() {
                {
                  put(
                    "products",
                    new FeedInjection().setInjection(
                      new Injection()
                        .setMain(
                          new InjectionMain().setSource(
                            new InjectionMainSearchSource().setSearch(
                              new MainSearch().setIndex("products").setParams(new MainInjectionQueryParameters().setHitsPerPage(12))
                            )
                          )
                        )
                        .setInjectedItems(
                          Arrays.asList(
                            new InjectionInjectedItem()
                              .setKey("featured-products")
                              .setSource(
                                new InjectedItemSearchSource().setSearch(
                                  new InjectedItemSearch()
                                    .setIndex("products")
                                    .setParams(new BaseInjectionQueryParameters().setFilters("featured:true"))
                                )
                              )
                              .setPosition(0)
                              .setLength(2)
                          )
                        )
                    )
                  );
                  put(
                    "articles",
                    new FeedInjection().setInjection(
                      new Injection()
                        .setMain(
                          new InjectionMain().setSource(
                            new InjectionMainSearchSource().setSearch(
                              new MainSearch()
                                .setIndex("articles")
                                .setParams(
                                  new MainInjectionQueryParameters()
                                    .setHitsPerPage(5)
                                    .setAttributesToRetrieve(Arrays.asList("title", "excerpt", "publishedAt"))
                                )
                            )
                          )
                        )
                        .setInjectedItems(
                          Arrays.asList(
                            new InjectionInjectedItem()
                              .setKey("editorial-picks")
                              .setSource(
                                new InjectedItemSearchSource().setSearch(
                                  new InjectedItemSearch()
                                    .setIndex("articles")
                                    .setParams(new BaseInjectionQueryParameters().setFilters("editorial_pick:true"))
                                )
                              )
                              .setPosition(0)
                              .setLength(1)
                          )
                        )
                    )
                  );
                  put(
                    "videos",
                    new FeedInjection().setInjection(
                      new Injection().setMain(
                        new InjectionMain().setSource(
                          new InjectionMainSearchSource().setSearch(
                            new MainSearch()
                              .setIndex("videos")
                              .setParams(
                                new MainInjectionQueryParameters()
                                  .setHitsPerPage(3)
                                  .setAttributesToRetrieve(Arrays.asList("title", "thumbnail", "duration"))
                              )
                          )
                        )
                      )
                    )
                  );
                }
              }
            )
            .setFeedsOrder(Arrays.asList("products", "articles", "videos"))
        )
      )
  );
  ```

  ```js JavaScript theme={"system"}
  const response = await client.putComposition({
    compositionID: 'my-compo',
    composition: {
      objectID: 'my-compo',
      name: 'my composition',
      behavior: {
        multifeed: {
          feeds: {
            products: {
              injection: {
                main: { source: { search: { index: 'products', params: { hitsPerPage: 12 } } } },
                injectedItems: [
                  {
                    key: 'featured-products',
                    source: { search: { index: 'products', params: { filters: 'featured:true' } } },
                    position: 0,
                    length: 2,
                  },
                ],
              },
            },
            articles: {
              injection: {
                main: {
                  source: {
                    search: {
                      index: 'articles',
                      params: { hitsPerPage: 5, attributesToRetrieve: ['title', 'excerpt', 'publishedAt'] },
                    },
                  },
                },
                injectedItems: [
                  {
                    key: 'editorial-picks',
                    source: { search: { index: 'articles', params: { filters: 'editorial_pick:true' } } },
                    position: 0,
                    length: 1,
                  },
                ],
              },
            },
            videos: {
              injection: {
                main: {
                  source: {
                    search: {
                      index: 'videos',
                      params: { hitsPerPage: 3, attributesToRetrieve: ['title', 'thumbnail', 'duration'] },
                    },
                  },
                },
              },
            },
          },
          feedsOrder: ['products', 'articles', 'videos'],
        },
      },
    },
  });
  ```

  ```kotlin Kotlin theme={"system"}
  var response =
    client.putComposition(
      compositionID = "my-compo",
      composition =
        Composition(
          objectID = "my-compo",
          name = "my composition",
          behavior =
            CompositionMultifeedBehavior(
              multifeed =
                Multifeed(
                  feeds =
                    mapOf(
                      "products" to
                        FeedInjection(
                          injection =
                            Injection(
                              main =
                                InjectionMain(
                                  source =
                                    InjectionMainSearchSource(
                                      search =
                                        MainSearch(
                                          index = "products",
                                          params = MainInjectionQueryParameters(hitsPerPage = 12),
                                        )
                                    )
                                ),
                              injectedItems =
                                listOf(
                                  InjectionInjectedItem(
                                    key = "featured-products",
                                    source =
                                      InjectedItemSearchSource(
                                        search =
                                          InjectedItemSearch(
                                            index = "products",
                                            params =
                                              BaseInjectionQueryParameters(
                                                filters = "featured:true"
                                              ),
                                          )
                                      ),
                                    position = 0,
                                    length = 2,
                                  )
                                ),
                            )
                        ),
                      "articles" to
                        FeedInjection(
                          injection =
                            Injection(
                              main =
                                InjectionMain(
                                  source =
                                    InjectionMainSearchSource(
                                      search =
                                        MainSearch(
                                          index = "articles",
                                          params =
                                            MainInjectionQueryParameters(
                                              hitsPerPage = 5,
                                              attributesToRetrieve =
                                                listOf("title", "excerpt", "publishedAt"),
                                            ),
                                        )
                                    )
                                ),
                              injectedItems =
                                listOf(
                                  InjectionInjectedItem(
                                    key = "editorial-picks",
                                    source =
                                      InjectedItemSearchSource(
                                        search =
                                          InjectedItemSearch(
                                            index = "articles",
                                            params =
                                              BaseInjectionQueryParameters(
                                                filters = "editorial_pick:true"
                                              ),
                                          )
                                      ),
                                    position = 0,
                                    length = 1,
                                  )
                                ),
                            )
                        ),
                      "videos" to
                        FeedInjection(
                          injection =
                            Injection(
                              main =
                                InjectionMain(
                                  source =
                                    InjectionMainSearchSource(
                                      search =
                                        MainSearch(
                                          index = "videos",
                                          params =
                                            MainInjectionQueryParameters(
                                              hitsPerPage = 3,
                                              attributesToRetrieve =
                                                listOf("title", "thumbnail", "duration"),
                                            ),
                                        )
                                    )
                                )
                            )
                        ),
                    ),
                  feedsOrder = listOf("products", "articles", "videos"),
                )
            ),
        ),
    )
  ```

  ```php PHP theme={"system"}
  $response = $client->putComposition(
      'my-compo',
      ['objectID' => 'my-compo',
          'name' => 'my composition',
          'behavior' => ['multifeed' => ['feeds' => ['products' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'products',
              'params' => ['hitsPerPage' => 12,
              ],
          ],
          ],
          ],
              'injectedItems' => [
                  ['key' => 'featured-products',
                      'source' => ['search' => ['index' => 'products',
                          'params' => ['filters' => 'featured:true',
                          ],
                      ],
                      ],
                      'position' => 0,
                      'length' => 2,
                  ],
              ],
          ],
          ],
              'articles' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'articles',
                  'params' => ['hitsPerPage' => 5,
                      'attributesToRetrieve' => [
                          'title',

                          'excerpt',

                          'publishedAt',
                      ],
                  ],
              ],
              ],
              ],
                  'injectedItems' => [
                      ['key' => 'editorial-picks',
                          'source' => ['search' => ['index' => 'articles',
                              'params' => ['filters' => 'editorial_pick:true',
                              ],
                          ],
                          ],
                          'position' => 0,
                          'length' => 1,
                      ],
                  ],
              ],
              ],
              'videos' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'videos',
                  'params' => ['hitsPerPage' => 3,
                      'attributesToRetrieve' => [
                          'title',

                          'thumbnail',

                          'duration',
                      ],
                  ],
              ],
              ],
              ],
              ],
              ],
          ],
              'feedsOrder' => [
                  'products',

                  'articles',

                  'videos',
              ],
          ],
          ],
      ],
  );
  ```

  ```python Python theme={"system"}
  response = client.put_composition(
      composition_id="my-compo",
      composition={
          "objectID": "my-compo",
          "name": "my composition",
          "behavior": {
              "multifeed": {
                  "feeds": {
                      "products": {
                          "injection": {
                              "main": {
                                  "source": {
                                      "search": {
                                          "index": "products",
                                          "params": {
                                              "hitsPerPage": 12,
                                          },
                                      },
                                  },
                              },
                              "injectedItems": [
                                  {
                                      "key": "featured-products",
                                      "source": {
                                          "search": {
                                              "index": "products",
                                              "params": {
                                                  "filters": "featured:true",
                                              },
                                          },
                                      },
                                      "position": 0,
                                      "length": 2,
                                  },
                              ],
                          },
                      },
                      "articles": {
                          "injection": {
                              "main": {
                                  "source": {
                                      "search": {
                                          "index": "articles",
                                          "params": {
                                              "hitsPerPage": 5,
                                              "attributesToRetrieve": [
                                                  "title",
                                                  "excerpt",
                                                  "publishedAt",
                                              ],
                                          },
                                      },
                                  },
                              },
                              "injectedItems": [
                                  {
                                      "key": "editorial-picks",
                                      "source": {
                                          "search": {
                                              "index": "articles",
                                              "params": {
                                                  "filters": "editorial_pick:true",
                                              },
                                          },
                                      },
                                      "position": 0,
                                      "length": 1,
                                  },
                              ],
                          },
                      },
                      "videos": {
                          "injection": {
                              "main": {
                                  "source": {
                                      "search": {
                                          "index": "videos",
                                          "params": {
                                              "hitsPerPage": 3,
                                              "attributesToRetrieve": [
                                                  "title",
                                                  "thumbnail",
                                                  "duration",
                                              ],
                                          },
                                      },
                                  },
                              },
                          },
                      },
                  },
                  "feedsOrder": [
                      "products",
                      "articles",
                      "videos",
                  ],
              },
          },
      },
  )
  ```

  ```ruby Ruby theme={"system"}
  response = client.put_composition(
    "my-compo",
    Algolia::Composition::Composition.new(
      algolia_object_id: "my-compo",
      name: "my composition",
      behavior: Algolia::Composition::CompositionMultifeedBehavior.new(
        multifeed: Algolia::Composition::Multifeed.new(
          feeds: {
            products: Algolia::Composition::FeedInjection.new(
              injection: Algolia::Composition::Injection.new(
                main: Algolia::Composition::InjectionMain.new(
                  source: Algolia::Composition::InjectionMainSearchSource.new(
                    search: Algolia::Composition::MainSearch.new(
                      index: "products",
                      params: Algolia::Composition::MainInjectionQueryParameters.new(hits_per_page: 12)
                    )
                  )
                ),
                injected_items: [
                  Algolia::Composition::InjectionInjectedItem.new(
                    key: "featured-products",
                    source: Algolia::Composition::InjectedItemSearchSource.new(
                      search: Algolia::Composition::InjectedItemSearch.new(
                        index: "products",
                        params: Algolia::Composition::BaseInjectionQueryParameters.new(filters: "featured:true")
                      )
                    ),
                    position: 0,
                    length: 2
                  )
                ]
              )
            ),
            articles: Algolia::Composition::FeedInjection.new(
              injection: Algolia::Composition::Injection.new(
                main: Algolia::Composition::InjectionMain.new(
                  source: Algolia::Composition::InjectionMainSearchSource.new(
                    search: Algolia::Composition::MainSearch.new(
                      index: "articles",
                      params: Algolia::Composition::MainInjectionQueryParameters.new(
                        hits_per_page: 5,
                        attributes_to_retrieve: ["title", "excerpt", "publishedAt"]
                      )
                    )
                  )
                ),
                injected_items: [
                  Algolia::Composition::InjectionInjectedItem.new(
                    key: "editorial-picks",
                    source: Algolia::Composition::InjectedItemSearchSource.new(
                      search: Algolia::Composition::InjectedItemSearch.new(
                        index: "articles",
                        params: Algolia::Composition::BaseInjectionQueryParameters.new(filters: "editorial_pick:true")
                      )
                    ),
                    position: 0,
                    length: 1
                  )
                ]
              )
            ),
            videos: Algolia::Composition::FeedInjection.new(
              injection: Algolia::Composition::Injection.new(
                main: Algolia::Composition::InjectionMain.new(
                  source: Algolia::Composition::InjectionMainSearchSource.new(
                    search: Algolia::Composition::MainSearch.new(
                      index: "videos",
                      params: Algolia::Composition::MainInjectionQueryParameters.new(
                        hits_per_page: 3,
                        attributes_to_retrieve: ["title", "thumbnail", "duration"]
                      )
                    )
                  )
                )
              )
            )
          },
          feeds_order: ["products", "articles", "videos"]
        )
      )
    )
  )
  ```

  ```scala Scala theme={"system"}
  val response = Await.result(
    client.putComposition(
      compositionID = "my-compo",
      composition = Composition(
        objectID = "my-compo",
        name = "my composition",
        behavior = CompositionMultifeedBehavior(
          multifeed = Multifeed(
            feeds = Map(
              "products" -> FeedInjection(
                injection = Injection(
                  main = InjectionMain(
                    source = Some(
                      InjectionMainSearchSource(
                        search = MainSearch(
                          index = "products",
                          params = Some(
                            MainInjectionQueryParameters(
                              hitsPerPage = Some(12)
                            )
                          )
                        )
                      )
                    )
                  ),
                  injectedItems = Some(
                    Seq(
                      InjectionInjectedItem(
                        key = "featured-products",
                        source = InjectedItemSearchSource(
                          search = InjectedItemSearch(
                            index = "products",
                            params = Some(
                              BaseInjectionQueryParameters(
                                filters = Some("featured:true")
                              )
                            )
                          )
                        ),
                        position = 0,
                        length = 2
                      )
                    )
                  )
                )
              ),
              "articles" -> FeedInjection(
                injection = Injection(
                  main = InjectionMain(
                    source = Some(
                      InjectionMainSearchSource(
                        search = MainSearch(
                          index = "articles",
                          params = Some(
                            MainInjectionQueryParameters(
                              hitsPerPage = Some(5),
                              attributesToRetrieve = Some(Seq("title", "excerpt", "publishedAt"))
                            )
                          )
                        )
                      )
                    )
                  ),
                  injectedItems = Some(
                    Seq(
                      InjectionInjectedItem(
                        key = "editorial-picks",
                        source = InjectedItemSearchSource(
                          search = InjectedItemSearch(
                            index = "articles",
                            params = Some(
                              BaseInjectionQueryParameters(
                                filters = Some("editorial_pick:true")
                              )
                            )
                          )
                        ),
                        position = 0,
                        length = 1
                      )
                    )
                  )
                )
              ),
              "videos" -> FeedInjection(
                injection = Injection(
                  main = InjectionMain(
                    source = Some(
                      InjectionMainSearchSource(
                        search = MainSearch(
                          index = "videos",
                          params = Some(
                            MainInjectionQueryParameters(
                              hitsPerPage = Some(3),
                              attributesToRetrieve = Some(Seq("title", "thumbnail", "duration"))
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            ),
            feedsOrder = Some(Seq("products", "articles", "videos"))
          )
        )
      )
    ),
    Duration(100, "sec")
  )
  ```

  ```swift Swift theme={"system"}
  let response = try await client.putComposition(
      compositionID: "my-compo",
      composition: Composition(
          objectID: "my-compo",
          name: "my composition",
          behavior: CompositionBehavior
              .compositionMultifeedBehavior(CompositionMultifeedBehavior(multifeed: Multifeed(
                  feeds: [
                      "products": FeedInjection(injection: Injection(
                          main: InjectionMain(source: InjectionMainSource
                              .injectionMainSearchSource(InjectionMainSearchSource(search: MainSearch(
                                  index: "products",
                                  params: MainInjectionQueryParameters(hitsPerPage: 12)
                              )))),
                          injectedItems: [InjectionInjectedItem(
                              key: "featured-products",
                              source: InjectedItemSource
                                  .injectedItemSearchSource(InjectedItemSearchSource(search: InjectedItemSearch(
                                      index: "products",
                                      params: BaseInjectionQueryParameters(filters: "featured:true")
                                  ))),
                              position: 0,
                              length: 2
                          )]
                      )),
                      "articles": FeedInjection(injection: Injection(
                          main: InjectionMain(source: InjectionMainSource
                              .injectionMainSearchSource(InjectionMainSearchSource(search: MainSearch(
                                  index: "articles",
                                  params: MainInjectionQueryParameters(
                                      attributesToRetrieve: ["title", "excerpt", "publishedAt"],
                                      hitsPerPage: 5
                                  )
                              )))),
                          injectedItems: [InjectionInjectedItem(
                              key: "editorial-picks",
                              source: InjectedItemSource
                                  .injectedItemSearchSource(InjectedItemSearchSource(search: InjectedItemSearch(
                                      index: "articles",
                                      params: BaseInjectionQueryParameters(filters: "editorial_pick:true")
                                  ))),
                              position: 0,
                              length: 1
                          )]
                      )),
                      "videos": FeedInjection(injection: Injection(main: InjectionMain(source: InjectionMainSource
                              .injectionMainSearchSource(InjectionMainSearchSource(search: MainSearch(
                                  index: "videos",
                                  params: MainInjectionQueryParameters(
                                      attributesToRetrieve: ["title", "thumbnail", "duration"],
                                      hitsPerPage: 3
                                  )
                              )))))),
                  ],
                  feedsOrder: ["products", "articles", "videos"]
              )))
      )
  )
  ```
</CodeGroup>

### 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](/doc/rest-api/composition/search).
Use the optional `feedsOrder` parameter to reorder, enable, or turn feeds off at run time, overriding the value defined in the composition itself.

<CodeGroup>
  ```cs C# theme={"system"}
  var response = await client.SearchAsync<Hit>(
    "foo",
    new RequestBody
    {
      Params = new Params { Query = "batman" },
      FeedsOrder = new List<string> { "feed-movies", "feed-comics" },
    }
  );
  ```

  ```dart Dart theme={"system"}
  final response = await client.search(
    compositionID: "foo",
    requestBody: RequestBody(
      params: Params(
        query: "batman",
      ),
      feedsOrder: [
        "feed-movies",
        "feed-comics",
      ],
    ),
  );
  ```

  ```go Go theme={"system"}
  response, err := client.Search(client.NewApiSearchRequest(
    "foo",
    composition.NewEmptyRequestBody().SetParams(
      composition.NewEmptyParams().SetQuery("batman")).SetFeedsOrder(
      []string{"feed-movies", "feed-comics"})))
  if err != nil {
    // handle the eventual error
    panic(err)
  }
  ```

  ```java Java theme={"system"}
  SearchResponse response = client.search(
    "foo",
    new RequestBody().setParams(new Params().setQuery("batman")).setFeedsOrder(Arrays.asList("feed-movies", "feed-comics")),
    Hit.class
  );
  ```

  ```js JavaScript theme={"system"}
  const response = await client.search({
    compositionID: 'foo',
    requestBody: { params: { query: 'batman' }, feedsOrder: ['feed-movies', 'feed-comics'] },
  });
  ```

  ```kotlin Kotlin theme={"system"}
  var response =
    client.search(
      compositionID = "foo",
      requestBody =
        RequestBody(
          params = Params(query = "batman"),
          feedsOrder = listOf("feed-movies", "feed-comics"),
        ),
    )
  ```

  ```php PHP theme={"system"}
  $response = $client->search(
      'foo',
      ['params' => ['query' => 'batman',
      ],
          'feedsOrder' => [
              'feed-movies',

              'feed-comics',
          ],
      ],
  );
  ```

  ```python Python theme={"system"}
  response = client.search(
      composition_id="foo",
      request_body={
          "params": {
              "query": "batman",
          },
          "feedsOrder": [
              "feed-movies",
              "feed-comics",
          ],
      },
  )
  ```

  ```ruby Ruby theme={"system"}
  response = client.search(
    "foo",
    Algolia::Composition::RequestBody.new(
      params: Algolia::Composition::Params.new(query: "batman"),
      feeds_order: ["feed-movies", "feed-comics"]
    )
  )
  ```

  ```scala Scala theme={"system"}
  val response = Await.result(
    client.search(
      compositionID = "foo",
      requestBody = RequestBody(
        params = Some(
          Params(
            query = Some("batman")
          )
        ),
        feedsOrder = Some(Seq("feed-movies", "feed-comics"))
      )
    ),
    Duration(100, "sec")
  )
  ```

  ```swift Swift theme={"system"}
  let response: CompositionSearchResponse<CompositionHit> = try await client.search(
      compositionID: "foo",
      requestBody: RequestBody(
          params: CompositionParams(query: "batman"),
          feedsOrder: ["feed-movies", "feed-comics"]
      )
  )
  ```
</CodeGroup>

The response includes one result set per feed, and the feeds are ordered based on the `feedsOrder` value.
Each feed's result set includes the corresponding `feedID` and Smart Groups injected into its <OrganicResults />, with deduplication applied within that feed.

```json JSON expandable icon=braces theme={"system"}
{
  "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"
    }
  ]
}
```

## Deduplication and facet management

Each feed in a multifeed composition is processed independently as a complete result set. This means:

* **Deduplication** applies within each feed according to your [deduplication strategy](/doc/guides/compositions/smart-groups/deduplication-strategy), preventing duplicate items between Smart Groups and <OrganicResults /> 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 multiple feeds 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.

## Integrate with InstantSearch

Before integrating multifeed compositions with InstantSearch, make sure you've completed the [base composition setup](/doc/guides/compositions/smart-groups/search-based-groups#integrate-compositions-with-instantsearch), including 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.

<CodeGroup>
  ```jsx React expandable theme={"system"}
  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>
        )}
      />
    );
  }
  ```

  ```js JavaScript expandable theme={"system"}
  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>
              `;
            },
          },
        }),
      ];
    },
  });
  ```

  ```vue Vue expandable theme={"system"}
  <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>
  ```
</CodeGroup>

### `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.

```jsx React icon=code theme={"system"}
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.

```jsx React icon=code theme={"system"}
<Feeds
  searchScope="global"
  transformFeeds={(feedIDs) => feedIDs.filter((id) => id !== "internal")}
  renderFeed={({ feedID }) => (
    <section>
      <Hits />
    </section>
  )}
/>
```

## Limits and considerations

* You can't use [sorting strategies](/doc/guides/compositions/sorting-strategy) with multifeed compositions
* All feeds share the same base <SearchQuery /> and parameters from the request
* Pagination applies independently to each feed