Return multiple result sets with multifeed compositions

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

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.

Multifeed compositions are ideal for federated search experiences that display results from different categories, brands, or content types at the same time.

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 sorting rules.

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 organic results.

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.

C#

var response = await client.PutCompositionAsync(
  "my-compo",
  new Composition
  {
    ObjectID = "my-compo",
    Name = "my composition",
    SortingStrategy = new Dictionary<string, string>
    {
      { "Price-asc", "products-low-to-high" },
      { "Price-desc", "products-high-to-low" },
    },
    Behavior = new CompositionBehavior(
      new CompositionMultifeedBehavior
      {
        Multifeed = new Multifeed
        {
          Feeds = new Dictionary<string, FeedInjection>
          {
            {
              "products",
              new FeedInjection
              {
                Injection = new Injection
                {
                  Main = new Main
                  {
                    Source = new CompositionSource
                    {
                      Search = new CompositionSourceSearch
                      {
                        Index = "products",
                        Params = new MainInjectionQueryParameters { HitsPerPage = 12 },
                      },
                    },
                  },
                  InjectedItems = new List<InjectedItem>
                  {
                    new InjectedItem
                    {
                      Key = "featured-products",
                      Source = new InjectedItemSource(
                        new SearchSource
                        {
                          Search = new Algolia.Search.Models.Composition.Search
                          {
                            Index = "products",
                            Params = new BaseInjectionQueryParameters
                            {
                              Filters = "featured:true",
                            },
                          },
                        }
                      ),
                      Position = 0,
                      Length = 2,
                    },
                  },
                },
              }
            },
            {
              "articles",
              new FeedInjection
              {
                Injection = new Injection
                {
                  Main = new Main
                  {
                    Source = new CompositionSource
                    {
                      Search = new CompositionSourceSearch
                      {
                        Index = "articles",
                        Params = new MainInjectionQueryParameters
                        {
                          HitsPerPage = 5,
                          AttributesToRetrieve = new List<string>
                          {
                            "title",
                            "excerpt",
                            "publishedAt",
                          },
                        },
                      },
                    },
                  },
                  InjectedItems = new List<InjectedItem>
                  {
                    new InjectedItem
                    {
                      Key = "editorial-picks",
                      Source = new InjectedItemSource(
                        new SearchSource
                        {
                          Search = new Algolia.Search.Models.Composition.Search
                          {
                            Index = "articles",
                            Params = new BaseInjectionQueryParameters
                            {
                              Filters = "editorial_pick:true",
                            },
                          },
                        }
                      ),
                      Position = 0,
                      Length = 1,
                    },
                  },
                },
              }
            },
            {
              "videos",
              new FeedInjection
              {
                Injection = new Injection
                {
                  Main = new Main
                  {
                    Source = new CompositionSource
                    {
                      Search = new CompositionSourceSearch
                      {
                        Index = "videos",
                        Params = new MainInjectionQueryParameters
                        {
                          HitsPerPage = 3,
                          AttributesToRetrieve = new List<string>
                          {
                            "title",
                            "thumbnail",
                            "duration",
                          },
                        },
                      },
                    },
                  },
                },
              }
            },
          },
          FeedsOrder = new List<string> { "products", "articles", "videos" },
        },
      }
    ),
  }
);

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.

C#

var response = await client.SearchAsync<Hit>(
  "foo",
  new RequestBody
  {
    Params = new Params { Query = "batman", SortBy = "Price (asc)" },
  }
);

The response includes one result set per feed. Each feed’s result set includes the corresponding feedID and Smart Groups injected into its organic results, with deduplication applied within that feed.

JSON

{
  "results": [
    {
      "feedID": "products",
      "resultSet": {
        "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",
      "resultSet": {
        "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",
      "resultSet": {
        "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, preventing duplicate items between Smart Groups and organic results 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.

Limits and considerations

• Sorting strategies aren’t applicable for multifeed compositions
• All feeds share the same base search query and parameters from the request
• Pagination applies independently to each feed