diff --git a/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_Dashboard.aspx.cs b/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_Dashboard.aspx.cs
index 3b6d62a..dd05fd4 100644
--- a/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_Dashboard.aspx.cs
+++ b/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_Dashboard.aspx.cs
@@ -4,7 +4,7 @@
 using CMS.Helpers;
 using CMS.Modules;
 
-using Kentico.Xperience.AlgoliaSearch.Attributes;
+using Kentico.Xperience.AlgoliaSearch.Models;
 using Kentico.Xperience.AlgoliaSearch.Services;
 
 using System;
@@ -23,7 +23,7 @@ protected void Page_Load(object sender, EventArgs e)
             var siteIndexes = algoliaRegistrationService.RegisteredIndexes.Where(i => i.SiteNames == null || i.SiteNames.Contains(CurrentSiteName));
             if (siteIndexes.Count() == 0)
             {
-                ShowInformation("No Algolia indexes registered. See <a target='_blank' href='https://github.com/Kentico/xperience-algolia#creating-and-registering-an-algolia-index'>our instructions</a> to read more about creating and registering Algolia indexes.");
+                ShowInformation("No Algolia indexes registered. See <a target='_blank' href='https://github.com/Kentico/xperience-algolia#gear-creating-and-registering-an-algolia-index'>our instructions</a> to read more about creating and registering Algolia indexes.");
                 return;
             }
 
@@ -42,7 +42,7 @@ private void ShowTaskCount()
         }
 
 
-        private void LoadIndexes(IEnumerable<RegisterAlgoliaIndexAttribute> indexes)
+        private void LoadIndexes(IEnumerable<AlgoliaIndex> indexes)
         {
             var indexesToList = new List<IndicesResponse>();
             var indexStatistics = algoliaSearchService.GetStatistics();
diff --git a/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_IndexedContent.aspx.cs b/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_IndexedContent.aspx.cs
index dc887cd..c13e4ea 100644
--- a/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_IndexedContent.aspx.cs
+++ b/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_IndexedContent.aspx.cs
@@ -1,6 +1,7 @@
 using CMS.Helpers;
 
 using Kentico.Xperience.AlgoliaSearch.Attributes;
+using Kentico.Xperience.AlgoliaSearch.Models;
 
 using System;
 using System.Collections.Generic;
@@ -12,7 +13,7 @@ namespace Kentico.Xperience.AlgoliaSearch.Pages
     public partial class AlgoliaSearch_IndexedContent : AlgoliaUIPage
     {
         private string indexName;
-        private RegisterAlgoliaIndexAttribute registerAlgoliaIndexAttribute;
+        private AlgoliaIndex algoliaIndex;
 
 
         protected override void OnLoad(EventArgs e)
@@ -26,16 +27,16 @@ protected override void OnLoad(EventArgs e)
                 return;
             }
 
-            var registerIndexAttribute = algoliaRegistrationService.RegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
-            if (registerIndexAttribute == null || registerIndexAttribute.Type == null)
+            var foundIndex = algoliaRegistrationService.RegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
+            if (foundIndex == null)
             {
-                ShowError("Unable to load index search model class.");
+                ShowError($"Error loading registered Algolia index '{indexName}.'");
                 return;
             }
 
-            ShowInformation($"The indexed columns and pages are defined in the class <b>{registerIndexAttribute.Type}</b>. To modify them, please contact your developer.");
+            ShowInformation($"The indexed columns and pages are defined in the class <b>{foundIndex.Type}</b>. To modify them, please contact your developer.");
 
-            registerAlgoliaIndexAttribute = registerIndexAttribute;
+            algoliaIndex = foundIndex;
             LoadProperties();
             LoadPaths();
         }
@@ -44,7 +45,7 @@ protected override void OnLoad(EventArgs e)
         private void LoadProperties()
         {
             var indexedProperties = new List<IndexedProperty>();
-            var modelProperties = registerAlgoliaIndexAttribute.Type.GetProperties();
+            var modelProperties = algoliaIndex.Type.GetProperties();
 
             foreach (var property in modelProperties)
             {
@@ -72,7 +73,7 @@ private void LoadProperties()
         private void LoadPaths()
         {
             var includedContent = new List<IncludedContent>();
-            var includedPathAttributes = registerAlgoliaIndexAttribute.Type.GetCustomAttributes(typeof(IncludedPathAttribute), false);
+            var includedPathAttributes = algoliaIndex.Type.GetCustomAttributes(typeof(IncludedPathAttribute), false);
             foreach (var includedPathAttribute in includedPathAttributes)
             {
                 var includedPath = includedPathAttribute as IncludedPathAttribute;
diff --git a/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_Preview.aspx.cs b/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_Preview.aspx.cs
index 2796344..a5ac931 100644
--- a/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_Preview.aspx.cs
+++ b/CMS/CMSModules/Kentico.Xperience.AlgoliaSearch/Pages/AlgoliaSearch_Preview.aspx.cs
@@ -21,8 +21,8 @@ public partial class AlgoliaSearch_Preview : AlgoliaUIPage
         protected override void OnLoad(EventArgs e)
         {
             base.OnLoad(e);
-            indexName = QueryHelper.GetString("indexName", "");
-            if (indexName == null)
+            indexName = QueryHelper.GetString("indexName", String.Empty);
+            if (String.IsNullOrEmpty(indexName))
             {
                 ShowError("Unable to load index name.");
                 searchPnl.Visible = false;
@@ -31,8 +31,8 @@ protected override void OnLoad(EventArgs e)
 
             if (!RequestHelper.IsPostBack())
             {
-                string searchText = QueryHelper.GetString("searchtext", "");
-                if (!string.IsNullOrEmpty(searchText))
+                string searchText = QueryHelper.GetString("searchtext", String.Empty);
+                if (!String.IsNullOrEmpty(searchText))
                 {
                     var searchIndexService = Service.Resolve<IAlgoliaIndexService>();
                     var searchIndex = searchIndexService.InitializeIndex(indexName);
diff --git a/README.md b/README.md
index c8cbcbd..65279fa 100644
--- a/README.md
+++ b/README.md
@@ -24,36 +24,24 @@ We recommend that you to create a new [.NET Standard 2.0](https://docs.microsoft
 }
 ```
 
-4. In the live-site project's startup code, call the `AddAlgolia()` extension method:
-
-```cs
-// Startup.cs
-public void ConfigureServices(IServiceCollection services)
-{
-    services.AddAlgolia(Configuration);
-}
-```
-
-5. In your administration project's `web.config` files's `appSettings` section, add the following keys:
+4. In your administration project's `web.config` files's `appSettings` section, add the following keys:
 
 ```xml
 <add key="AlgoliaApplicationId" value="<your application ID>"/>
 <add key="AlgoliaApiKey" value="<your Admin API key>"/>
 ```
 
+5. Register the `IAlgoliaIndexRegister` service and any indexes by following [this guide](#gear-creating-and-registering-an-algolia-index).
 6. (Optional) Import the [Xperience Algolia module](#chart_with_upwards_trend-algolia-search-application-for-administration-interface) in your Xperience website.
 
 ## :gear: Creating and registering an Algolia index
 
 An Algolia index and its attributes are defined within a single class file, in which your custom class extends the [`AlgoliaSearchModel`](https://github.com/Kentico/xperience-algolia/blob/master/src/Models/AlgoliaSearchModel.cs) class. Within the class, you define the attributes of the index by creating properties which match the names of Xperience page fields to index. The Xperience fields available may come from the `TreeNode` object, `SKUTreeNode` for products, or any custom page type fields.
 
-The index is registered via the [`RegisterAlgoliaIndex`](https://github.com/Kentico/xperience-algolia/blob/master/src/Attributes/RegisterAlgoliaIndexAttribute.cs) attribute which requires the type of the search model class and the code name of the Algolia index. Optionally, you can provide a list of `SiteNames` to which the index is assigned. If not provided, pages from all sites are included.
-
 ```cs
 using Kentico.Xperience.AlgoliaSearch.Models;
 using System;
 
-[assembly: RegisterAlgoliaIndex(typeof(AlgoliaSiteSearchModel), AlgoliaSiteSearchModel.IndexName, SiteNames = new string[] { "DancingGoatCore" })]
 namespace DancingGoat
 {
     public class AlgoliaSiteSearchModel : AlgoliaSearchModel
@@ -71,6 +59,43 @@ namespace DancingGoat
 
 > :ab: The property names (and names used in the [SourceAttribute](#source-attribute)) are __case-insensitive__. This means that your search model can contain an "articletext" property, or an "ArticleText" property- both will work.
 
+Indexes must be registered during application startup in both the administration application and the live-site application. In the __administration__ project, create a [custom module](https://docs.xperience.io/custom-development/creating-custom-modules/initializing-modules-to-run-custom-code) and use the `OnPreInit` method to create an `IAlgoliaIndexRegister`, add your indexes, and register the service:
+
+```cs
+protected override void OnPreInit()
+{
+    base.OnPreInit();
+
+    Service.Use<IAlgoliaIndexRegister>(new DefaultAlgoliaIndexRegister()
+        .Add<AlgoliaSiteSearchModel>(AlgoliaSiteSearchModel.IndexName)
+    );
+}
+```
+
+The `Add` method also accepts an optional list of `SiteNames` to which the index is assigned. If not provided, pages from all sites are included. In the __live-site__ project's startup code, call the `AddAlgolia()` extension method and add your indexes to the `IAlgoliaIndexRegister`:
+
+```cs
+// Startup.cs
+public void ConfigureServices(IServiceCollection services)
+{
+    services.AddAlgolia(Configuration,
+        new DefaultAlgoliaIndexRegister()
+            .Add<AlgoliaSiteSearchModel>(AlgoliaSiteSearchModel.IndexName)
+    );
+}
+```
+
+If you're developing your search solution in multiple environments (e.g. "DEV" and "STG"), it is recommended that you create a unique Algolia index per environment. With this approach, the search functionality can be tested in each environment individually and changes to the index structure or content will not affect other environments. This can be implemented any way you'd like, including some custom service which transforms the index names. The simplest approach would be to prepend some environment name to the index, which is stored in the application settings:
+
+```cs
+var environment = ConfigurationManager.AppSettings["Environment"];
+Service.Use<IAlgoliaIndexRegister>(new DefaultAlgoliaIndexRegister()
+    .Add<AlgoliaSiteSearchModel>($"{environment}-{AlgoliaSiteSearchModel.IndexName}")
+);
+```
+
+> :triangular_flag_on_post: The method of registering indexes via [`RegisterAlgoliaIndex`](https://github.com/Kentico/xperience-algolia/blob/master/src/Attributes/RegisterAlgoliaIndexAttribute.cs) is still supported, but no longer recommended.
+
 ### Determining which pages to index
 
 While the above sample code will create an Algolia index, pages in the content tree will not be indexed until one or more [`IncludedPathAttribute`](https://github.com/Kentico/xperience-algolia/blob/master/src/Attributes/IncludedPathAttribute.cs) attributes are applied to the class. The `IncludedPathAttribute` has three properties to configure:
@@ -89,48 +114,44 @@ All pages under the specified __AliasPath__ will be indexed regardless of the [p
 Below is an example of an Algolia index which includes multiple paths and page types:
 
 ```cs
-[assembly: RegisterAlgoliaIndex(typeof(AlgoliaSiteSearchModel), AlgoliaSiteSearchModel.IndexName)]
-namespace DancingGoat
+[IncludedPath("/Articles/%", PageTypes = new string[] { Article.CLASS_NAME })]
+[IncludedPath("/Store/%", PageTypes = new string[] { "DancingGoatCore.Brewer", "DancingGoatCore.Coffee", "DancingGoatCore.ElectricGrinder", "DancingGoatCore.FilterPack", "DancingGoatCore.ManualGrinder", "DancingGoatCore.Tableware" })]
+public class AlgoliaSiteSearchModel : AlgoliaSearchModel
 {
-    [IncludedPath("/Articles/%", PageTypes = new string[] { Article.CLASS_NAME })]
-    [IncludedPath("/Store/%", PageTypes = new string[] { "DancingGoatCore.Brewer", "DancingGoatCore.Coffee", "DancingGoatCore.ElectricGrinder", "DancingGoatCore.FilterPack", "DancingGoatCore.ManualGrinder", "DancingGoatCore.Tableware" })]
-    public class AlgoliaSiteSearchModel : AlgoliaSearchModel
-    {
-        public const string IndexName = "DancingGoatSiteSearch";
+    public const string IndexName = "DancingGoatSiteSearch";
 
-        [Searchable, Retrievable]
-        public string DocumentName { get; set; }
+    [Searchable, Retrievable]
+    public string DocumentName { get; set; }
 
-        [Url, Retrievable]
-        [Source(new string[] { nameof(SKUTreeNode.SKU.SKUImagePath), nameof(Article.ArticleTeaser) })]
-        public string Thumbnail { get; set; }
+    [Url, Retrievable]
+    [Source(new string[] { nameof(SKUTreeNode.SKU.SKUImagePath), nameof(Article.ArticleTeaser) })]
+    public string Thumbnail { get; set; }
 
-        [Searchable]
-        [Source(new string[] { nameof(SKUTreeNode.DocumentSKUDescription), nameof(Article.ArticleText) })]
-        public string Content { get; set; }
+    [Searchable]
+    [Source(new string[] { nameof(SKUTreeNode.DocumentSKUDescription), nameof(Article.ArticleText) })]
+    public string Content { get; set; }
 
-        [Searchable, Retrievable]
-        [Source(new string[] { nameof(SKUTreeNode.DocumentSKUShortDescription), nameof(Article.ArticleSummary) })]
-        public string ShortDescription { get; set; }
+    [Searchable, Retrievable]
+    [Source(new string[] { nameof(SKUTreeNode.DocumentSKUShortDescription), nameof(Article.ArticleSummary) })]
+    public string ShortDescription { get; set; }
 
-        [Retrievable]
-        public int SKUID { get; set; }
+    [Retrievable]
+    public int SKUID { get; set; }
 
-        [Facetable, Retrievable]
-        public decimal? SKUPrice { get; set; }
+    [Facetable, Retrievable]
+    public decimal? SKUPrice { get; set; }
 
-        [Retrievable]
-        public int SKUPublicStatusID { get; set; }
+    [Retrievable]
+    public int SKUPublicStatusID { get; set; }
 
-        [Retrievable]
-        public DateTime DocumentCreatedWhen { get; set; }
+    [Retrievable]
+    public DateTime DocumentCreatedWhen { get; set; }
 
-        [Facetable]
-        public string CoffeeProcessing { get; set; }
+    [Facetable]
+    public string CoffeeProcessing { get; set; }
 
-        [Facetable]
-        public bool CoffeeIsDecaf { get; set; }
-    }
+    [Facetable]
+    public bool CoffeeIsDecaf { get; set; }
 }
 ```
 
@@ -445,7 +466,6 @@ Algolia provides [autocomplete](https://www.algolia.com/doc/ui-libraries/autocom
 
 ```cshtml
 @inject IConfiguration configuration
-
 @{
     var algoliaOptions = configuration.GetSection(AlgoliaOptions.SECTION_NAME).Get<AlgoliaOptions>();
 }
@@ -700,6 +720,7 @@ private SearchResponse<AlgoliaSiteSearchModel> Search(IAlgoliaFacetFilter filter
         Facets = facetsToRetrieve
     };
 
+
     var searchIndex = _indexService.InitializeIndex(AlgoliaSiteSearchModel.IndexName);
     return searchIndex.Search<AlgoliaSiteSearchModel>(query);
 }
@@ -942,6 +963,7 @@ You can also log an event when a visitor simply views a page with the `LogPageVi
 public async Task<IActionResult> Detail([FromServices] ArticleRepository articleRepository)
 {
     var article = articleRepository.GetCurrent();
+
     await _insightsService.LogPageViewed(article.DocumentID, "Article viewed", AlgoliaSiteSearchModel.IndexName);
 
     return new TemplateResult(article);
@@ -1011,7 +1033,7 @@ In the appropriate controller, create the action which accepts the facet paramet
 
 ```cs
 [HttpPost]
-public Task<ActionResult> FacetClicked(string facet)
+public async Task<ActionResult> FacetClicked(string facet)
 {
     if (String.IsNullOrEmpty(facet))
     {
@@ -1066,7 +1088,6 @@ endpoints.MapControllerRoute(
 
 ```cshtml
 @inject IConfiguration configuration
-
 @{
     var algoliaOptions = configuration.GetSection(AlgoliaOptions.SECTION_NAME).Get<AlgoliaOptions>();
 }
@@ -1105,7 +1126,7 @@ endpoints.MapControllerRoute(
     <script src="https://cdn.jsdelivr.net/npm/instantsearch.js@4"></script>
     <script type="text/javascript">
         const search = instantsearch({
-          indexName: '@DancingGoatSiteIndexModel.IndexName',
+          indexName: '@AlgoliaSiteSearchModel.IndexName',
           searchClient: algoliasearch('@algoliaOptions.ApplicationId', '@algoliaOptions.SearchKey'),
         });
 
diff --git a/src/AlgoliaStartupExtensions.cs b/src/AlgoliaStartupExtensions.cs
index c88cb04..ec2a14b 100644
--- a/src/AlgoliaStartupExtensions.cs
+++ b/src/AlgoliaStartupExtensions.cs
@@ -1,6 +1,7 @@
 using Algolia.Search.Clients;
 
 using Kentico.Xperience.AlgoliaSearch.Models;
+using Kentico.Xperience.AlgoliaSearch.Services;
 
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -15,12 +16,13 @@ namespace Kentico.Xperience.AlgoliaSearch
     public static class AlgoliaStartupExtensions
     {
         /// <summary>
-        /// Registers instances of <see cref="IInsightsClient"/> and <see cref="ISearchClient"/>
-        /// with Dependency Injection.
+        /// Registers instances of <see cref="IInsightsClient"/>, <see cref="ISearchClient"/>, and
+        /// <see cref="IAlgoliaIndexRegister"/> with Dependency Injection.
         /// </summary>
         /// <param name="services">The service collection.</param>
         /// <param name="configuration">The application configuration.</param>
-        public static IServiceCollection AddAlgolia(this IServiceCollection services, IConfiguration configuration)
+        /// <param name="register">The implementation of <see cref="IAlgoliaIndexRegister"/> to register.</param>
+        public static IServiceCollection AddAlgolia(this IServiceCollection services, IConfiguration configuration, IAlgoliaIndexRegister register)
         {
             var algoliaOptions = configuration.GetSection(AlgoliaOptions.SECTION_NAME).Get<AlgoliaOptions>();
             if (String.IsNullOrEmpty(algoliaOptions.ApplicationId) || String.IsNullOrEmpty(algoliaOptions.ApiKey))
@@ -36,6 +38,7 @@ public static IServiceCollection AddAlgolia(this IServiceCollection services, IC
 
             services.AddSingleton<IInsightsClient>(insightsClient);
             services.AddSingleton<ISearchClient>(searchClient);
+            services.AddSingleton(register);
 
             return services;
         }
diff --git a/src/Attributes/RegisterAlgoliaIndexAttribute.cs b/src/Attributes/RegisterAlgoliaIndexAttribute.cs
index d4771fb..d131770 100644
--- a/src/Attributes/RegisterAlgoliaIndexAttribute.cs
+++ b/src/Attributes/RegisterAlgoliaIndexAttribute.cs
@@ -26,6 +26,7 @@ public Type Type
         public string IndexName
         {
             get;
+            internal set;
         }
 
 
diff --git a/src/Kentico.Xperience.AlgoliaSearch.csproj b/src/Kentico.Xperience.AlgoliaSearch.csproj
index 28c59d5..02f9a31 100644
--- a/src/Kentico.Xperience.AlgoliaSearch.csproj
+++ b/src/Kentico.Xperience.AlgoliaSearch.csproj
@@ -9,7 +9,7 @@
 	<PropertyGroup>
 		<Title>Xperience Algolia Search</Title>
 		<PackageId>Kentico.Xperience.AlgoliaSearch</PackageId>
-		<Version>2.4.0</Version>
+		<Version>3.0.0</Version>
 		<Authors>Kentico Software</Authors>
 		<Company>Kentico Software</Company>
 		<PackageIcon>icon.png</PackageIcon>
diff --git a/src/Models/AlgoliaIndex.cs b/src/Models/AlgoliaIndex.cs
new file mode 100644
index 0000000..6dec8e8
--- /dev/null
+++ b/src/Models/AlgoliaIndex.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+
+namespace Kentico.Xperience.AlgoliaSearch.Models
+{
+    /// <summary>
+    /// Represents the configuration of an Algolia index.
+    /// </summary>
+    public class AlgoliaIndex
+    {
+        /// <summary>
+        /// The type of the class which extends <see cref="AlgoliaSearchModel"/>.
+        /// </summary>
+        public Type Type
+        {
+            get;
+            set;
+        }
+
+
+        /// <summary>
+        /// The code name of the Algolia index.
+        /// </summary>
+        public string IndexName
+        {
+            get;
+            set;
+        }
+
+
+        /// <summary>
+        /// The code names of the sites whose pages will be included in the index. If empty, all sites
+        /// are included.
+        /// </summary>
+        public IEnumerable<string> SiteNames
+        {
+            get;
+            set;
+        }
+    }
+}
diff --git a/src/Services/IAlgoliaIndexRegister.cs b/src/Services/IAlgoliaIndexRegister.cs
new file mode 100644
index 0000000..03794ae
--- /dev/null
+++ b/src/Services/IAlgoliaIndexRegister.cs
@@ -0,0 +1,30 @@
+using Kentico.Xperience.AlgoliaSearch.Models;
+
+using System.Collections.Generic;
+
+namespace Kentico.Xperience.AlgoliaSearch.Services
+{
+    /// <summary>
+    /// Contains a collection of <see cref="AlgoliaIndex"/> which are automatically registered by
+    /// <see cref="IAlgoliaRegistrationService"/> during application startup.
+    /// </summary>
+    public interface IAlgoliaIndexRegister
+    {
+        /// <summary>
+        /// Inserts an <see cref="AlgoliaIndex"/> into the register.
+        /// </summary>
+        /// <typeparam name="TModel">The search model class.</typeparam>
+        /// <param name="indexName">The code name of the Algolia index.</param>
+        /// <param name="siteNames">The code names of the sites whose pages will be included in the index.
+        /// If empty, all sites are included.</param>
+        /// <returns>The <see cref="IAlgoliaRegistrationService"/> for chaining.</returns>
+        IAlgoliaIndexRegister Add<TModel>(string indexName, IEnumerable<string> siteNames = null) where TModel : AlgoliaSearchModel;
+
+
+        /// <summary>
+        /// Pops off the first <see cref="AlgoliaIndex"/> in the register, or <c>null</c> if the register
+        /// is empty.
+        /// </summary>
+        AlgoliaIndex Pop();
+    }
+}
diff --git a/src/Services/IAlgoliaRegistrationService.cs b/src/Services/IAlgoliaRegistrationService.cs
index a59704b..c6b8037 100644
--- a/src/Services/IAlgoliaRegistrationService.cs
+++ b/src/Services/IAlgoliaRegistrationService.cs
@@ -4,10 +4,10 @@
 using CMS.DocumentEngine;
 
 using Kentico.Xperience.AlgoliaSearch.Attributes;
+using Kentico.Xperience.AlgoliaSearch.Models;
 
 using System;
 using System.Collections.Generic;
-using System.Reflection;
 
 namespace Kentico.Xperience.AlgoliaSearch.Services
 {
@@ -18,23 +18,14 @@ namespace Kentico.Xperience.AlgoliaSearch.Services
     public interface IAlgoliaRegistrationService
     {
         /// <summary>
-        /// A collection of registered Algolia indexes as identified by the
-        /// <see cref="RegisterAlgoliaIndexAttribute"/> in the search model class.
+        /// A collection of registered Algolia indexes.
         /// </summary>
-        List<RegisterAlgoliaIndexAttribute> RegisteredIndexes
+        List<AlgoliaIndex> RegisteredIndexes
         {
             get;
         }
 
 
-        /// <summary>
-        /// Gets all <see cref="RegisterAlgoliaIndexAttribute"/>s present in the provided assembly.
-        /// </summary>
-        /// <remarks>Logs an error if the were issues scanning the assembly.</remarks>
-        /// <param name="assembly">The assembly to scan for attributes.</param>
-        IEnumerable<RegisterAlgoliaIndexAttribute> GetAlgoliaIndexAttributes(Assembly assembly);
-
-
         /// <summary>
         /// Gets the <see cref="IndexSettings"/> of the Algolia index.
         /// </summary>
@@ -76,20 +67,22 @@ List<RegisterAlgoliaIndexAttribute> RegisteredIndexes
 
         /// <summary>
         /// Scans all discoverable assemblies for instances of <see cref="RegisterAlgoliaIndexAttribute"/>s
-        /// and stores the Algolia index name and search model class in memory. Also calls
-        /// <see cref="SearchIndex.SetSettings"/> to initialize the Algolia index's configuration
-        /// based on the attributes defined in the search model.
+        /// and stores the <see cref="AlgoliaIndex"/> in memory, in addition to all indexes in the
+        /// <see cref="IAlgoliaIndexRegister"/>.
         /// </summary>
-        /// <remarks>Logs an error if the index settings cannot be loaded.</remarks>
         void RegisterAlgoliaIndexes();
 
 
         /// <summary>
-        /// Saves an Algolia index's configuration to <see cref="RegisteredIndexes"/>.
+        /// Stores an <see cref="AlgoliaIndex"/> in memory based on the provided parameters. Also calls
+        /// <see cref="SearchIndex.SetSettings"/> to initialize the Algolia index's configuration
+        /// based on the attributes defined in the <paramref name="searchModel"/>.
         /// </summary>
-        /// <remarks>Logs errors if the parameters are invalid, or the index is already registered.</remarks>
-        /// <param name="registerAlgoliaIndexAttribute">The <see cref="RegisterAlgoliaIndexAttribute"/> defined
-        /// in the search model code file.</param>
-        void RegisterIndex(RegisterAlgoliaIndexAttribute registerAlgoliaIndexAttribute);
+        /// <param name="searchModel">The type of the class which extends <see cref="AlgoliaSearchModel"/>.</param>
+        /// <param name="indexName">The code name of the Algolia index.</param>
+        /// <param name="siteNames">The code names of the sites whose pages will be included in the index.
+        /// If empty, all sites are included.</param>
+        /// <remarks>Logs an error if the index settings cannot be loaded.</remarks>
+        void RegisterIndex(Type searchModel, string indexName, IEnumerable<string> siteNames = null);
     }
 }
diff --git a/src/Services/Implementations/DefaultAlgoliaConnection.cs b/src/Services/Implementations/DefaultAlgoliaConnection.cs
index fadbaa7..7520238 100644
--- a/src/Services/Implementations/DefaultAlgoliaConnection.cs
+++ b/src/Services/Implementations/DefaultAlgoliaConnection.cs
@@ -23,10 +23,11 @@ namespace Kentico.Xperience.AlgoliaSearch.Services
     /// </summary>
     internal class DefaultAlgoliaConnection : IAlgoliaConnection
     {
-        private SearchIndex searchIndex;
-        private RegisterAlgoliaIndexAttribute registerIndexAttribute;
+        private ISearchIndex searchIndex;
+        private AlgoliaIndex algoliaIndex;
         private readonly ISearchClient searchClient;
         private readonly IEventLogService eventLogService;
+        private readonly IAlgoliaIndexService algoliaIndexService;
         private readonly IAlgoliaRegistrationService algoliaRegistrationService;
 
 
@@ -35,10 +36,12 @@ internal class DefaultAlgoliaConnection : IAlgoliaConnection
         /// </summary>
         public DefaultAlgoliaConnection(ISearchClient searchClient,
             IEventLogService eventLogService,
+            IAlgoliaIndexService algoliaIndexService,
             IAlgoliaRegistrationService algoliaRegistrationService)
         {
             this.searchClient = searchClient;
             this.eventLogService = eventLogService;
+            this.algoliaIndexService = algoliaIndexService;
             this.algoliaRegistrationService = algoliaRegistrationService;
         }
 
@@ -50,18 +53,13 @@ public void Initialize(string indexName)
                 throw new ArgumentNullException(indexName);
             }
 
-            registerIndexAttribute = algoliaRegistrationService.RegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
-            if (registerIndexAttribute == null)
+            algoliaIndex = algoliaRegistrationService.RegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
+            if (algoliaIndex == null)
             {
-                throw new InvalidOperationException($"Unable to load registration attribute for index '{indexName}.'");
+                throw new InvalidOperationException($"Error loading registered Algolia index '{indexName}.'");
             }
 
-            if (!registerIndexAttribute.Type.IsSubclassOf(typeof(AlgoliaSearchModel)))
-            {
-                throw new InvalidOperationException($"Algolia search models must extend the {nameof(AlgoliaSearchModel)} class.");
-            }
-
-            searchIndex = searchClient.InitIndex(indexName);
+            searchIndex = algoliaIndexService.InitializeIndex(indexName);
         }
 
 
@@ -111,7 +109,7 @@ public int UpsertRecords(IEnumerable<JObject> dataObjects)
 
         public void Rebuild()
         {
-            if (registerIndexAttribute.Type == null)
+            if (algoliaIndex.Type == null)
             {
                 throw new InvalidOperationException("No registered search model class found for index.");
             }
@@ -119,7 +117,7 @@ public void Rebuild()
             searchIndex.ClearObjects();
 
             var indexedNodes = new List<TreeNode>();
-            var includedPathAttributes = registerIndexAttribute.Type.GetCustomAttributes<IncludedPathAttribute>(false);
+            var includedPathAttributes = algoliaIndex.Type.GetCustomAttributes<IncludedPathAttribute>(false);
             foreach (var includedPathAttribute in includedPathAttributes)
             {
                 var query = new MultiDocumentQuery()
@@ -137,9 +135,9 @@ public void Rebuild()
                     query.Culture(includedPathAttribute.Cultures);
                 }
 
-                if (registerIndexAttribute.SiteNames.Length > 0)
+                if (algoliaIndex.SiteNames != null && algoliaIndex.SiteNames.Count() > 0)
                 {
-                    foreach (var site in registerIndexAttribute.SiteNames)
+                    foreach (var site in algoliaIndex.SiteNames)
                     {
                         query.OnSite(site).Or();
                     }
@@ -151,7 +149,7 @@ public void Rebuild()
             AlgoliaQueueWorker.EnqueueAlgoliaQueueItems(indexedNodes.Select(node =>
                 new AlgoliaQueueItem
                 {
-                    IndexName = registerIndexAttribute.IndexName,
+                    IndexName = algoliaIndex.IndexName,
                     Node = node,
                     Deleted = false
                 }
diff --git a/src/Services/Implementations/DefaultAlgoliaIndexRegister.cs b/src/Services/Implementations/DefaultAlgoliaIndexRegister.cs
new file mode 100644
index 0000000..57c9995
--- /dev/null
+++ b/src/Services/Implementations/DefaultAlgoliaIndexRegister.cs
@@ -0,0 +1,41 @@
+using Kentico.Xperience.AlgoliaSearch.Models;
+
+using System;
+using System.Collections.Generic;
+
+namespace Kentico.Xperience.AlgoliaSearch.Services
+{
+    /// <summary>
+    /// Default implementation of <see cref="IAlgoliaIndexRegister"/>.
+    /// </summary>
+    public class DefaultAlgoliaIndexRegister : IAlgoliaIndexRegister
+    {
+        private readonly Stack<AlgoliaIndex> indexes = new Stack<AlgoliaIndex>();
+
+
+        public IAlgoliaIndexRegister Add<TModel>(string indexName, IEnumerable<string> siteNames = null) where TModel : AlgoliaSearchModel
+        {
+            indexes.Push(new AlgoliaIndex
+            {
+                IndexName = indexName,
+                Type = typeof(TModel),
+                SiteNames = siteNames
+            });
+
+            return this;
+        }
+
+
+        public AlgoliaIndex Pop()
+        {
+            try
+            {
+                return indexes.Pop();
+            }
+            catch (InvalidOperationException)
+            {
+                return null;
+            }
+        }
+    }
+}
diff --git a/src/Services/Implementations/DefaultAlgoliaIndexService.cs b/src/Services/Implementations/DefaultAlgoliaIndexService.cs
index 4e6cdf6..0ed2dca 100644
--- a/src/Services/Implementations/DefaultAlgoliaIndexService.cs
+++ b/src/Services/Implementations/DefaultAlgoliaIndexService.cs
@@ -9,8 +9,7 @@
 namespace Kentico.Xperience.AlgoliaSearch.Services
 {
     /// <summary>
-    /// Default implementation of <see cref="IAlgoliaIndexService"/> which simply calls
-    /// <see cref="ISearchClient.InitIndex(string)"/>.
+    /// Default implementation of <see cref="IAlgoliaIndexService"/>.
     /// </summary>
     internal class DefaultAlgoliaIndexService : IAlgoliaIndexService
     {
diff --git a/src/Services/Implementations/DefaultAlgoliaIndexingService.cs b/src/Services/Implementations/DefaultAlgoliaIndexingService.cs
index 4ee24f6..4fb57d5 100644
--- a/src/Services/Implementations/DefaultAlgoliaIndexingService.cs
+++ b/src/Services/Implementations/DefaultAlgoliaIndexingService.cs
@@ -106,8 +106,8 @@ public int ProcessAlgoliaTasks(IEnumerable<AlgoliaQueueItem> items)
                 {
                     algoliaConnection.Initialize(group.Key);
 
-                    var registerIndexAttribute = algoliaRegistrationService.RegisteredIndexes.FirstOrDefault(i => i.IndexName == group.Key);
-                    if (registerIndexAttribute == null)
+                    var algoliaIndex = algoliaRegistrationService.RegisteredIndexes.FirstOrDefault(i => i.IndexName == group.Key);
+                    if (algoliaIndex == null)
                     {
                         eventLogService.LogError(nameof(DefaultAlgoliaIndexingService), nameof(ProcessAlgoliaTasks), $"Attempted to process tasks for index '{group.Key},' but the index is not registered.");
                         continue;
@@ -115,7 +115,7 @@ public int ProcessAlgoliaTasks(IEnumerable<AlgoliaQueueItem> items)
 
                     var deleteTasks = group.Where(queueItem => queueItem.Deleted);
                     var updateTasks = group.Where(queueItem => !queueItem.Deleted);
-                    var upsertData = updateTasks.Select(queueItem => GetTreeNodeData(queueItem.Node, registerIndexAttribute.Type)).ToList();
+                    var upsertData = updateTasks.Select(queueItem => GetTreeNodeData(queueItem.Node, algoliaIndex.Type)).ToList();
                     var deleteData = deleteTasks.Select(queueItem => queueItem.Node.DocumentID.ToString()).ToList();
 
                     successfulOperations += algoliaConnection.UpsertRecords(upsertData);
diff --git a/src/Services/Implementations/DefaultAlgoliaRegistrationService.cs b/src/Services/Implementations/DefaultAlgoliaRegistrationService.cs
index 3b3b7e9..3d0bcc9 100644
--- a/src/Services/Implementations/DefaultAlgoliaRegistrationService.cs
+++ b/src/Services/Implementations/DefaultAlgoliaRegistrationService.cs
@@ -26,7 +26,8 @@ internal class DefaultAlgoliaRegistrationService : IAlgoliaRegistrationService
         private readonly IEventLogService eventLogService;
         private readonly ISearchClient searchClient;
         private readonly IAlgoliaIndexService algoliaIndexService;
-        private readonly List<RegisterAlgoliaIndexAttribute> mRegisteredIndexes = new List<RegisterAlgoliaIndexAttribute>();
+        private readonly IAlgoliaIndexRegister algoliaIndexRegister;
+        private readonly List<AlgoliaIndex> mRegisteredIndexes = new List<AlgoliaIndex>();
         private readonly string[] ignoredPropertiesForTrackingChanges = new string[] {
             nameof(AlgoliaSearchModel.ObjectID),
             nameof(AlgoliaSearchModel.Url),
@@ -34,7 +35,7 @@ internal class DefaultAlgoliaRegistrationService : IAlgoliaRegistrationService
         };
 
 
-        public List<RegisterAlgoliaIndexAttribute> RegisteredIndexes
+        public List<AlgoliaIndex> RegisteredIndexes
         {
             get
             {
@@ -49,30 +50,14 @@ public List<RegisterAlgoliaIndexAttribute> RegisteredIndexes
         public DefaultAlgoliaRegistrationService(IAlgoliaSearchService algoliaSearchService,
             IEventLogService eventLogService,
             ISearchClient searchClient,
-            IAlgoliaIndexService algoliaIndexService)
+            IAlgoliaIndexService algoliaIndexService,
+            IAlgoliaIndexRegister algoliaIndexRegister)
         {
             this.algoliaSearchService = algoliaSearchService;
             this.eventLogService = eventLogService;
             this.searchClient = searchClient;
             this.algoliaIndexService = algoliaIndexService;
-        }
-
-
-        public IEnumerable<RegisterAlgoliaIndexAttribute> GetAlgoliaIndexAttributes(Assembly assembly)
-        {
-            var attributes = Enumerable.Empty<RegisterAlgoliaIndexAttribute>();
-
-            try
-            {
-                attributes = assembly.GetCustomAttributes(typeof(RegisterAlgoliaIndexAttribute), false)
-                                    .Cast<RegisterAlgoliaIndexAttribute>();
-            }
-            catch (Exception exception)
-            {
-                eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(GetAlgoliaIndexAttributes), $"Failed to register Algolia indexes for assembly '{assembly.FullName}:' {exception.Message}.");
-            }
-
-            return attributes;
+            this.algoliaIndexRegister = algoliaIndexRegister;
         }
 
 
@@ -83,16 +68,16 @@ public IndexSettings GetIndexSettings(string indexName)
                 throw new ArgumentNullException(nameof(indexName));
             }
 
-            var registerIndexAttribute = mRegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
-            if (registerIndexAttribute == null || registerIndexAttribute.Type == null)
+            var alogliaIndex = mRegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
+            if (alogliaIndex == null)
             {
                 return null;
             }
 
-            var searchableProperties = registerIndexAttribute.Type.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(SearchableAttribute)));
-            var retrievablProperties = registerIndexAttribute.Type.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(RetrievableAttribute)));
-            var facetableProperties = registerIndexAttribute.Type.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(FacetableAttribute)));
-            ;
+            var searchableProperties = alogliaIndex.Type.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(SearchableAttribute)));
+            var retrievablProperties = alogliaIndex.Type.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(RetrievableAttribute)));
+            var facetableProperties = alogliaIndex.Type.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(FacetableAttribute)));
+            
             return new IndexSettings()
             {
                 SearchableAttributes = algoliaSearchService.OrderSearchableProperties(searchableProperties),
@@ -104,16 +89,16 @@ public IndexSettings GetIndexSettings(string indexName)
 
         public string[] GetIndexedColumnNames(string indexName)
         {
-            var registerIndexAttribute = mRegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
-            if (registerIndexAttribute == null || registerIndexAttribute.Type == null)
+            var alogliaIndex = mRegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
+            if (alogliaIndex == null)
             {
                 return new string[] { };
             }
 
             // Don't include properties with SourceAttribute at first, check the sources and add to list after
-            var indexedColumnNames = registerIndexAttribute.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
+            var indexedColumnNames = alogliaIndex.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                 .Where(prop => !Attribute.IsDefined(prop, typeof(SourceAttribute))).Select(prop => prop.Name).ToList();
-            var propertiesWithSourceAttribute = registerIndexAttribute.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
+            var propertiesWithSourceAttribute = alogliaIndex.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
                 .Where(prop => Attribute.IsDefined(prop, typeof(SourceAttribute)));
             foreach (var property in propertiesWithSourceAttribute)
             {
@@ -163,23 +148,19 @@ public bool IsNodeIndexedByIndex(TreeNode node, string indexName)
                 throw new ArgumentNullException(nameof(node));
             }
 
-            var registerIndexAttribute = mRegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
-            if (registerIndexAttribute == null || registerIndexAttribute.Type == null)
+            var alogliaIndex = mRegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
+            if (alogliaIndex == null)
             {
-                eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(IsNodeIndexedByIndex), $"Error loading search model class for index '{indexName}.'");
+                eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(IsNodeIndexedByIndex), $"Error loading registered Algolia index '{indexName}.'");
                 return false;
             }
 
-            var registrationAttribute = mRegisteredIndexes.FirstOrDefault(i => i.IndexName == indexName);
-            if (registrationAttribute != null)
+            if (alogliaIndex.SiteNames != null && !alogliaIndex.SiteNames.Contains(node.NodeSiteName))
             {
-                if (registrationAttribute.SiteNames != null && !registrationAttribute.SiteNames.Contains(node.NodeSiteName))
-                {
-                    return false;
-                }
+                return false;
             }
-
-            var includedPathAttributes = registerIndexAttribute.Type.GetCustomAttributes<IncludedPathAttribute>(false);
+            
+            var includedPathAttributes = alogliaIndex.Type.GetCustomAttributes<IncludedPathAttribute>(false);
             foreach (var includedPathAttribute in includedPathAttributes)
             {
                 var path = includedPathAttribute.AliasPath;
@@ -219,51 +200,81 @@ public void RegisterAlgoliaIndexes()
 
             foreach (var attribute in attributes)
             {
-                try
-                {
-                    RegisterIndex(attribute);
-
-                    var searchIndex = algoliaIndexService.InitializeIndex(attribute.IndexName);
-                    var indexSettings = GetIndexSettings(attribute.IndexName);
-                    if (indexSettings == null)
-                    {
-                        eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterAlgoliaIndexes), $"Unable to load search index settings for index '{attribute.IndexName}.'");
-                        continue;
-                    }
+                RegisterIndex(attribute.Type, attribute.IndexName, attribute.SiteNames);
+            }
 
-                    searchIndex.SetSettings(indexSettings);
-                    
-                }
-                catch (Exception ex)
-                {
-                    mRegisteredIndexes.Remove(attribute);
-                    eventLogService.LogException(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterAlgoliaIndexes), ex, additionalMessage: $"Cannot register Algolia index '{attribute.IndexName}.'");
-                }
+            var algoliaIndex = algoliaIndexRegister.Pop();
+            while (algoliaIndex != null)
+            {
+                RegisterIndex(algoliaIndex.Type, algoliaIndex.IndexName, algoliaIndex.SiteNames);
+                algoliaIndex = algoliaIndexRegister.Pop();
             }
         }
 
 
-        public void RegisterIndex(RegisterAlgoliaIndexAttribute registerAlgoliaIndexAttribute)
+        public void RegisterIndex(Type searchModel, string indexName, IEnumerable<string> siteNames = null)
         {
-            if (String.IsNullOrEmpty(registerAlgoliaIndexAttribute.IndexName))
+            if (String.IsNullOrEmpty(indexName))
             {
                 eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterIndex), "Cannot register Algolia index with empty or null code name.");
                 return;
             }
 
-            if (registerAlgoliaIndexAttribute.Type == null)
+            if (searchModel == null)
             {
-                eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterIndex), "Cannot register Algolia index with null search model class.");
+                eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterIndex), "Cannot register Algolia index with null search model type.");
                 return;
             }
 
-            if (mRegisteredIndexes.Any(i => i.IndexName == registerAlgoliaIndexAttribute.IndexName))
+            if (mRegisteredIndexes.Any(i => i.IndexName == indexName))
             {
-                eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterIndex), $"Attempted to register Algolia index with name '{registerAlgoliaIndexAttribute.IndexName},' but it is already registered.");
+                eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterIndex), $"Attempted to register Algolia index with name '{indexName},' but it is already registered.");
                 return;
             }
 
-            mRegisteredIndexes.Add(registerAlgoliaIndexAttribute);
+            var algoliaIndex = new AlgoliaIndex
+            {
+                IndexName = indexName,
+                Type = searchModel,
+                SiteNames = siteNames
+            };
+            try
+            {
+                mRegisteredIndexes.Add(algoliaIndex);
+
+                var searchIndex = algoliaIndexService.InitializeIndex(indexName);
+                var indexSettings = GetIndexSettings(indexName);
+                if (indexSettings == null)
+                {
+                    eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterIndex), $"Unable to load search index settings for index '{indexName}.'");
+                    return;
+                }
+
+                searchIndex.SetSettings(indexSettings);
+            }
+            catch (Exception ex)
+            {
+                mRegisteredIndexes.Remove(algoliaIndex);
+                eventLogService.LogException(nameof(DefaultAlgoliaRegistrationService), nameof(RegisterIndex), ex, additionalMessage: $"Cannot register Algolia index '{indexName}.'");
+            }
+        }
+
+
+        private IEnumerable<RegisterAlgoliaIndexAttribute> GetAlgoliaIndexAttributes(Assembly assembly)
+        {
+            var attributes = Enumerable.Empty<RegisterAlgoliaIndexAttribute>();
+
+            try
+            {
+                attributes = assembly.GetCustomAttributes(typeof(RegisterAlgoliaIndexAttribute), false)
+                                    .Cast<RegisterAlgoliaIndexAttribute>();
+            }
+            catch (Exception exception)
+            {
+                eventLogService.LogError(nameof(DefaultAlgoliaRegistrationService), nameof(GetAlgoliaIndexAttributes), $"Failed to register Algolia indexes for assembly '{assembly.FullName}:' {exception.Message}.");
+            }
+
+            return attributes;
         }
     }
 }
diff --git a/tests/Base/AlgoliaTests.cs b/tests/Base/AlgoliaTests.cs
index 3b7df43..c9a34e8 100644
--- a/tests/Base/AlgoliaTests.cs
+++ b/tests/Base/AlgoliaTests.cs
@@ -1,4 +1,5 @@
-using CMS.DocumentEngine;
+using CMS;
+using CMS.DocumentEngine;
 using CMS.SiteProvider;
 using CMS.Tests;
 
@@ -7,6 +8,7 @@
 using Tests.DocumentEngine;
 
 [assembly: Category("Algolia")]
+[assembly: AssemblyDiscoverable]
 namespace Kentico.Xperience.AlgoliaSearch.Test
 {
     internal class AlgoliaTests : UnitTests
diff --git a/tests/Fakes/TestSearchModels.cs b/tests/Fakes/TestSearchModels.cs
index a6291d2..3c35ac8 100644
--- a/tests/Fakes/TestSearchModels.cs
+++ b/tests/Fakes/TestSearchModels.cs
@@ -131,5 +131,16 @@ public class Model7 : ModelBaseClass
             [Searchable]
             public string NodeAliasPath { get; set; }
         }
+
+
+        [IncludedPath("/Articles/%")]
+        public class Model8 : AlgoliaSearchModel
+        {
+            public const string IndexName = "Model8";
+
+
+            [Searchable]
+            public string DocumentCreatedWhen { get; set; }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/Kentico.Xperience.AlgoliaSearch.Tests.csproj b/tests/Kentico.Xperience.AlgoliaSearch.Tests.csproj
index 4d2371f..0e6628e 100644
--- a/tests/Kentico.Xperience.AlgoliaSearch.Tests.csproj
+++ b/tests/Kentico.Xperience.AlgoliaSearch.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="Kentico.Xperience.Libraries.Tests" Version="13.0.16" />
+    <PackageReference Include="Kentico.Xperience.Libraries.Tests" Version="13.0.73" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="3.1.8" />
     <PackageReference Include="NSubstitute" Version="4.3.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
diff --git a/tests/Tests/IAlgoliaIndexRegisterTests.cs b/tests/Tests/IAlgoliaIndexRegisterTests.cs
new file mode 100644
index 0000000..a884dbe
--- /dev/null
+++ b/tests/Tests/IAlgoliaIndexRegisterTests.cs
@@ -0,0 +1,70 @@
+using Algolia.Search.Clients;
+
+using Kentico.Xperience.AlgoliaSearch.Services;
+
+using NSubstitute;
+
+using NUnit.Framework;
+
+using static Kentico.Xperience.AlgoliaSearch.Test.TestSearchModels;
+
+namespace Kentico.Xperience.AlgoliaSearch.Test
+{
+    internal class IAlgoliaIndexRegisterTests
+    {
+        [TestFixture]
+        internal class IndexRegistrationTests : AlgoliaTests
+        {
+            [Test]
+            public void ValidIndex_IsRegistered()
+            {
+                var indexRegister = new DefaultAlgoliaIndexRegister()
+                    .Add<Model8>(Model8.IndexName);
+
+                var algoliaRegistrationService = GetRegistrationService(indexRegister);
+                algoliaRegistrationService.RegisterAlgoliaIndexes();
+
+                Assert.AreEqual(8, algoliaRegistrationService.RegisteredIndexes.Count);
+            }
+
+
+            [Test]
+            public void DuplicateIndexes_NotRegistered()
+            {
+                var indexRegister = new DefaultAlgoliaIndexRegister()
+                    .Add<Model8>(Model8.IndexName)
+                    .Add<Model8>(Model8.IndexName)
+                    .Add<Model8>(Model8.IndexName);
+
+                var algoliaRegistrationService = GetRegistrationService(indexRegister);
+                algoliaRegistrationService.RegisterAlgoliaIndexes();
+
+                Assert.AreEqual(8, algoliaRegistrationService.RegisteredIndexes.Count);
+            }
+
+
+            [Test]
+            public void IndexRegisteredWithAttribute_NotRegistered()
+            {
+                var indexRegister = new DefaultAlgoliaIndexRegister()
+                    .Add<Model7>(Model7.IndexName);
+
+                var algoliaRegistrationService = GetRegistrationService(indexRegister);
+                algoliaRegistrationService.RegisterAlgoliaIndexes();
+
+                Assert.AreEqual(7, algoliaRegistrationService.RegisteredIndexes.Count);
+            }
+
+
+            private IAlgoliaRegistrationService GetRegistrationService(IAlgoliaIndexRegister indexRegister)
+            {
+                return new DefaultAlgoliaRegistrationService(
+                    Substitute.For<IAlgoliaSearchService>(),
+                    new MockEventLogService(),
+                    Substitute.For<ISearchClient>(),
+                    Substitute.For<IAlgoliaIndexService>(),
+                    indexRegister);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/Tests/IAlgoliaIndexingServiceTests.cs b/tests/Tests/IAlgoliaIndexingServiceTests.cs
index bc21853..b0224f1 100644
--- a/tests/Tests/IAlgoliaIndexingServiceTests.cs
+++ b/tests/Tests/IAlgoliaIndexingServiceTests.cs
@@ -1,7 +1,6 @@
 using CMS.DataEngine;
 using CMS.DocumentEngine;
 
-using Kentico.Xperience.AlgoliaSearch.Attributes;
 using Kentico.Xperience.AlgoliaSearch.Models;
 using Kentico.Xperience.AlgoliaSearch.Services;
 
@@ -124,11 +123,23 @@ internal class ProcessAlgoliaTasksTests : AlgoliaTests
             public void ProcessAlgoliaTasksTests_SetUp()
             {
                 var mockRegistrationService = Substitute.For<IAlgoliaRegistrationService>();
-                mockRegistrationService.RegisteredIndexes.Returns(new List<RegisterAlgoliaIndexAttribute>() {
-                    new RegisterAlgoliaIndexAttribute(typeof(Model1), Model1.IndexName),
-                    new RegisterAlgoliaIndexAttribute(typeof(Model2), Model2.IndexName),
-                    new RegisterAlgoliaIndexAttribute(typeof(Model3), Model3.IndexName),
-                    new RegisterAlgoliaIndexAttribute(typeof(Model4), Model4.IndexName)
+                mockRegistrationService.RegisteredIndexes.Returns(new List<AlgoliaIndex>() {
+                    new AlgoliaIndex{
+                        IndexName = Model1.IndexName,
+                        Type = typeof(Model1)
+                    },
+                    new AlgoliaIndex{
+                        IndexName = Model2.IndexName,
+                        Type = typeof(Model2)
+                    },
+                    new AlgoliaIndex{
+                        IndexName = Model3.IndexName,
+                        Type = typeof(Model3)
+                    },
+                    new AlgoliaIndex{
+                        IndexName = Model4.IndexName,
+                        Type = typeof(Model4)
+                    }
                 });
 
                 var mockAlgoliaConnection = Substitute.For<IAlgoliaConnection>();
diff --git a/tests/Tests/IAlgoliaRegistrationServiceTests.cs b/tests/Tests/IAlgoliaRegistrationServiceTests.cs
index 91880bc..22a7f83 100644
--- a/tests/Tests/IAlgoliaRegistrationServiceTests.cs
+++ b/tests/Tests/IAlgoliaRegistrationServiceTests.cs
@@ -5,7 +5,6 @@
 using CMS.DocumentEngine;
 using CMS.SiteProvider;
 
-using Kentico.Xperience.AlgoliaSearch.Attributes;
 using Kentico.Xperience.AlgoliaSearch.Services;
 
 using NSubstitute;
@@ -13,7 +12,6 @@
 using NUnit.Framework;
 
 using System;
-using System.Reflection;
 
 using static Kentico.Xperience.AlgoliaSearch.Test.TestSearchModels;
 
@@ -32,13 +30,13 @@ public void GetIndexSettingsTests_SetUp()
             {
                 var mockSearchClient = Substitute.For<ISearchClient>();
                 var algoliaSearchService = new DefaultAlgoliaSearchService(mockSearchClient, Substitute.For<IAppSettingsService>());
-                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(algoliaSearchService, new MockEventLogService(), mockSearchClient, Substitute.For<IAlgoliaIndexService>());
-
-                var attributes = algoliaRegistrationService.GetAlgoliaIndexAttributes(Assembly.GetExecutingAssembly());
-                foreach (var attribute in attributes)
-                {
-                    algoliaRegistrationService.RegisterIndex(attribute);
-                }
+                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(
+                    algoliaSearchService,
+                    new MockEventLogService(),
+                    mockSearchClient,
+                    Substitute.For<IAlgoliaIndexService>(),
+                    Substitute.For<IAlgoliaIndexRegister>());
+                algoliaRegistrationService.RegisterAlgoliaIndexes();
             }
 
 
@@ -86,13 +84,6 @@ public string[] GetIndexSettings_SearchableAttributes_PropertiesConvertedToArray
             }
 
 
-            [Test]
-            public void GetIndexSettings_IndexWithInvalidConfiguration_ThrowsInvalidOperationException()
-            {
-                Assert.Throws<InvalidOperationException>(() => algoliaRegistrationService.GetIndexSettings(Model6.IndexName));
-            }
-
-
             [Test]
             public void GetIndexSettings_IndexInheritsBaseClass_ContainsPropertiesFromAllClasses()
             {
@@ -115,13 +106,13 @@ internal class IsNodeAlgoliaIndexed : AlgoliaTests
             [SetUp]
             public void IsNodeAlgoliaIndexed_SetUp()
             {
-                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(Substitute.For<IAlgoliaSearchService>(), new MockEventLogService(), Substitute.For<ISearchClient>(), Substitute.For<IAlgoliaIndexService>());
-
-                var attributes = algoliaRegistrationService.GetAlgoliaIndexAttributes(Assembly.GetExecutingAssembly());
-                foreach (var attribute in attributes)
-                {
-                    algoliaRegistrationService.RegisterIndex(attribute);
-                }
+                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(
+                    Substitute.For<IAlgoliaSearchService>(),
+                    new MockEventLogService(),
+                    Substitute.For<ISearchClient>(),
+                    Substitute.For<IAlgoliaIndexService>(),
+                    Substitute.For<IAlgoliaIndexRegister>());
+                algoliaRegistrationService.RegisterAlgoliaIndexes();
             }
 
 
@@ -154,13 +145,13 @@ internal class IsNodeIndexedByIndexTests : AlgoliaTests
             [SetUp]
             public void IsNodeIndexedByIndexTests_SetUp()
             {
-                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(Substitute.For<IAlgoliaSearchService>(), new MockEventLogService(), Substitute.For<ISearchClient>(), Substitute.For<IAlgoliaIndexService>());
-
-                var attributes = algoliaRegistrationService.GetAlgoliaIndexAttributes(Assembly.GetExecutingAssembly());
-                foreach (var attribute in attributes)
-                {
-                    algoliaRegistrationService.RegisterIndex(attribute);
-                }
+                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(
+                    Substitute.For<IAlgoliaSearchService>(),
+                    new MockEventLogService(),
+                    Substitute.For<ISearchClient>(),
+                    Substitute.For<IAlgoliaIndexService>(),
+                    Substitute.For<IAlgoliaIndexRegister>());
+                algoliaRegistrationService.RegisterAlgoliaIndexes();
             }
 
 
@@ -229,13 +220,13 @@ internal class GetIndexedColumnNamesTests : AlgoliaTests
             [SetUp]
             public void GetIndexedColumnNamesTests_SetUp()
             {
-                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(Substitute.For<IAlgoliaSearchService>(), new MockEventLogService(), Substitute.For<ISearchClient>(), Substitute.For<IAlgoliaIndexService>());
-
-                var attributes = algoliaRegistrationService.GetAlgoliaIndexAttributes(Assembly.GetExecutingAssembly());
-                foreach (var attribute in attributes)
-                {
-                    algoliaRegistrationService.RegisterIndex(attribute);
-                }
+                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(
+                    Substitute.For<IAlgoliaSearchService>(),
+                    new MockEventLogService(),
+                    Substitute.For<ISearchClient>(),
+                    Substitute.For<IAlgoliaIndexService>(),
+                    Substitute.For<IAlgoliaIndexRegister>());
+                algoliaRegistrationService.RegisterAlgoliaIndexes();
             }
 
 
@@ -263,16 +254,21 @@ internal class RegisterIndexTests : AlgoliaTests
             [SetUp]
             public void RegisterIndexTests_SetUp()
             {
-                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(Substitute.For<IAlgoliaSearchService>(), new MockEventLogService(), Substitute.For<ISearchClient>(), Substitute.For<IAlgoliaIndexService>());
+                algoliaRegistrationService = new DefaultAlgoliaRegistrationService(
+                    Substitute.For<IAlgoliaSearchService>(),
+                    new MockEventLogService(),
+                    Substitute.For<ISearchClient>(),
+                    Substitute.For<IAlgoliaIndexService>(),
+                    Substitute.For<IAlgoliaIndexRegister>());
             }
 
 
             [Test]
             public void RegisterIndex_ValidIndexes_AreRegistered()
             {
-                algoliaRegistrationService.RegisterIndex(new RegisterAlgoliaIndexAttribute(typeof(Model1), Model1.IndexName));
-                algoliaRegistrationService.RegisterIndex(new RegisterAlgoliaIndexAttribute(typeof(Model2), Model2.IndexName));
-                algoliaRegistrationService.RegisterIndex(new RegisterAlgoliaIndexAttribute(typeof(Model3), Model3.IndexName));
+                algoliaRegistrationService.RegisterIndex(typeof(Model1), Model1.IndexName);
+                algoliaRegistrationService.RegisterIndex(typeof(Model2), Model2.IndexName);
+                algoliaRegistrationService.RegisterIndex(typeof(Model3), Model3.IndexName);
 
                 Assert.AreEqual(3, algoliaRegistrationService.RegisteredIndexes.Count);
             }
@@ -281,7 +277,7 @@ public void RegisterIndex_ValidIndexes_AreRegistered()
             [Test]
             public void RegisterIndex_EmptyIndexName_DoesntRegisterIndex()
             {
-                algoliaRegistrationService.RegisterIndex(new RegisterAlgoliaIndexAttribute(typeof(Model1), String.Empty));
+                algoliaRegistrationService.RegisterIndex(typeof(Model1), String.Empty);
 
                 Assert.AreEqual(0, algoliaRegistrationService.RegisteredIndexes.Count);
             }
@@ -290,7 +286,7 @@ public void RegisterIndex_EmptyIndexName_DoesntRegisterIndex()
             [Test]
             public void RegisterIndex_NullSearchModel_DoesntRegisterIndex()
             {
-                algoliaRegistrationService.RegisterIndex(new RegisterAlgoliaIndexAttribute(null, "FAKE_NAME"));
+                algoliaRegistrationService.RegisterIndex(null, "FAKE_NAME");
 
                 Assert.AreEqual(0, algoliaRegistrationService.RegisteredIndexes.Count);
             }
@@ -299,8 +295,8 @@ public void RegisterIndex_NullSearchModel_DoesntRegisterIndex()
             [Test]
             public void RegisterIndex_DuplicateIndexName_DoesntRegisterIndex()
             {
-                algoliaRegistrationService.RegisterIndex(new RegisterAlgoliaIndexAttribute(typeof(Model1), Model1.IndexName));
-                algoliaRegistrationService.RegisterIndex(new RegisterAlgoliaIndexAttribute(typeof(Model1), Model1.IndexName));
+                algoliaRegistrationService.RegisterIndex(typeof(Model1), Model1.IndexName);
+                algoliaRegistrationService.RegisterIndex(typeof(Model1), Model1.IndexName);
 
                 Assert.AreEqual(1, algoliaRegistrationService.RegisteredIndexes.Count);
             }