How to Connect Coveo Search to AEM as a Cloud Service

Across industries, search functionality remains one of the most critical features of modern websites. For years—before the introduction of AEM as a Cloud Service (AEMaaCS)—many search providers offered custom “connectors” to integrate their services with AEM. However, most of these connectors were built for on-premise AEM environments and have since been deprecated, as they no longer align with the architectural patterns and best practices introduced by AEMaaCS.

This is the case with Coveo, which previously relied on a dedicated AEM connector to index content and integrate with AEM. In this post, I’ll walk you through the latest and recommended approaches for integrating Coveo with AEMaaCS.

TL;DR

Use the Coveo Sitemap Connector to index your content. This requires setting up a sitemap in AEM (either EDS or AEMaaCS), which is now a relatively straightforward process.

Once your content is indexed, you must choose a method for displaying Coveo search functionality on your site. The Atomic framework usually provides the best balance between implementation time and complexity.

Indexing Content in Coveo

In the context of search, indexing refers to the process of making content available to a search engine for future retrieval during search operations. While Coveo offers multiple ways to index content, the recommended approaches for AEM as a Cloud Service (AEMaaCS) are either the Sitemap Connector or the Web Crawling Connector.

Web Connector

The Web Connector starts from a defined entry point (typically a page URL) and crawls all pages it can discover through links found in the DOM. This process continues recursively until all reachable pages are indexed. It works similarly to how a traditional search engine crawls a website.

Sitemap Connector

The Sitemap Connector is the preferred method for indexing content in AEMaaCS. It works similarly to the Web Connector but is more efficient, as it uses a predefined sitemap that lists all relevant URLs. This approach avoids unnecessary crawling and allows for more intelligent indexing operations.

Why the Sitemap Connector is Preferred

Overall, the Sitemap Connector provides greater control over what content is indexed or excluded, aligning fully with AEM as a Cloud Service best practices. Below are some key benefits:

• Faster indexing due to a predefined list of URLs

• Supports incremental indexing using lastMod metadata

• More control over what content is indexed or excluded

• Compatible with AEMaaCS best practices

• Works well with AEM’s native sitemap generation features

For those using Edge Delivery Services, sitemap generation is also well-supported and well-documented. (Learn more about Sitemap Generation for EDS.)

Creating a Data Source in the Coveo Dashboard

Once your sitemap is publicly accessible, you can head over to the Coveo Dashboard and create a new data source. One of the key requirements during setup is providing the URL of your sitemap.

Coveo offers a wide range of features and configuration options, which are well-documented in their official resources. That said, the basic setup is relatively straightforward—especially if you don't need highly customized configurations. After creating the data source, you can initiate the indexing process. In most cases, you'll start seeing results within a few minutes, allowing you to quickly validate that the correct content is being indexed. This is particularly useful if you leverage additional metadata for facets, filters, or other advanced search capabilities.

Building a Search UI with Coveo

Now that your content is indexed and searchable, the next step is to decide how to display the search functionality on your site. Coveo offers multiple options for building a search UI, tailored to the level of customization, complexity, and development effort you're aiming for.

To help with this decision, Coveo provides a helpful decision graph that guides you through the available UI options based on your requirements:

Now, let's analyze the possibilities.

Simple Builder

Coveo provides a Simple Builder within its dashboard—a dedicated section for creating a search page UI without writing code. This tool is primarily designed for non-developers, offering a straightforward way to build a functional search experience. While customiz

This option is ideal if you’re looking for a quick and easy setup. Once you've configured elements such as facets, tags, and labels, Coveo generates a Search Page ID that you can use to embed the search experience into your site.

From an AEM perspective, this search page can be integrated into a dedicated component to render the experience.

<!--/* NOTE: The credentials required for the snippet below can be obtained from the Coveo dashboard. */-->
<script
    async
    onload="CoveoSearchPage.initialize(${key @ context='html'})"
    src="https://search.cloud.coveo.com/rest/organizations/${coveoModel.orgId @ context='html'}/searchpage/v1/interfaces/${coveoModel.searchPageId @ context='html'}/loader"
  ></script>

When embedded, the search page will appear and function exactly as it does within the Search Builder Editor.

Atomic Library

Coveo provides a set of prebuilt web components known as the Atomic Library. These components provide a flexible and modular approach to creating a fully customized search experience. Designed for developers, the Atomic Library strikes a great balance between ease of use and deep customization—particularly when it comes to appearance, branding, and layout.

In most cases, the Atomic Library is the preferred approach for teams that want more control over the design and behavior of their search UI while still benefiting from prebuilt functionality.

<!DOCTYPE html>
<html>
  <head>
    <script
      type="module"
      src="https://static.cloud.coveo.com/atomic/v3/atomic.esm.js"
    ></script> 
    <script>
      (async () => {
        await customElements.whenDefined("atomic-search-interface"); 
        const searchInterface = document.querySelector("#search");

        await searchInterface.initialize({ 
          accessToken: "XXXX",
          organizationId: "XXXX",
        });
        searchInterface.executeFirstSearch(); 
      })();
    </script>
  </head>
  <body>
    <atomic-search-interface id="search">
      <atomic-search-layout> 
      <!-- all Atomic components will go in here -->
      </atomic-search-layout>
    </atomic-search-interface>
  </body>
</html>

Headless

Coveo Headless is a flexible way to build custom search experiences by connecting your own user interface directly to Coveo’s search engine. Think of Headless as the engine under the hood that handles all the search logic and data, while you design and build the frontend however you like. This approach works well if you want a highly personalized search experience or need to integrate search deeply into a complex site or app. It does require more programming skills and time compared to using prebuilt components, but it also offers the most freedom and flexibility.

This approach isn’t overly complicated, but it does have a learning curve that shouldn’t be underestimated—especially if you’re working with tight deadlines. If you don’t need a lot of flexibility or deep customization, it’s usually better to avoid a headless approach or ensure you allow enough time for development and testing.

REST API

At the core of Coveo’s functionality, the REST API underpins both the Atomic and Headless libraries. While you technically can build a completely custom search experience using direct REST API calls, this is rarely necessary—and often discouraged unless you have very specific, low-level integration needs. In most scenarios, Headless provides sufficient flexibility without the overhead of manually managing API requests. However, it's worth knowing that the REST API exists as a fallback option for edge cases or highly specialized requirements.

Wrapping Up

Integrating a search engine can sometimes feel overwhelming, particularly when multiple ways exist to achieve the same outcome. In this blog, I’ve aimed to simplify the process by outlining the best approaches for integrating the Coveo search engine with AEM as a Cloud Service today.