diff --git a/src/libraries/Microsoft.Extensions.Hosting/src/Internal/Host.cs b/src/libraries/Microsoft.Extensions.Hosting/src/Internal/Host.cs
index efeb09405ff2ba..4625a1e57685d2 100644
--- a/src/libraries/Microsoft.Extensions.Hosting/src/Internal/Host.cs
+++ b/src/libraries/Microsoft.Extensions.Hosting/src/Internal/Host.cs
@@ -66,6 +66,7 @@ public Host(IServiceProvider services,
         /// Order:
         ///  IHostLifetime.WaitForStartAsync
         ///  Services.GetService{IStartupValidator}().Validate()
+        ///  Services.GetService{IAsyncStartupValidator}().ValidateAsync()
         ///  IHostedLifecycleService.StartingAsync
         ///  IHostedService.Start
         ///  IHostedLifecycleService.StartedAsync
@@ -96,12 +97,31 @@ public async Task StartAsync(CancellationToken cancellationToken = default)
                     _hostedServices ??= Services.GetRequiredService<IEnumerable<IHostedService>>();
                     _hostedLifecycleServices = GetHostLifecycles(_hostedServices);
 
-                    // Call startup validators.
+                    // Two-stage startup validation:
+                    // Stage 1 (sync): Run IStartupValidator.Validate() — iterates _validators dictionary
+                    //   (or user's custom implementation if registered).
+                    //   If sync validation fails, skip async to avoid expensive I/O on invalid config.
+                    // Stage 2 (async): Run IAsyncStartupValidator.ValidateAsync() — iterates _asyncValidators
+                    //   dictionary (or user's custom implementation if registered).
+                    //
+                    // Each interface is resolved independently via DI. TryAddTransient semantics ensure
+                    // user-registered implementations replace the built-in for each interface separately.
                     IStartupValidator? validator = Services.GetService<IStartupValidator>();
                     validator?.Validate();
+
+                    IAsyncStartupValidator? asyncValidator = Services.GetService<IAsyncStartupValidator>();
+                    if (asyncValidator is not null)
+                    {
+                        await asyncValidator.ValidateAsync(cancellationToken).ConfigureAwait(false);
+                    }
                 }
                 catch (Exception ex)
                 {
+                    if (ex is OperationCanceledException)
+                    {
+                        cancellationToken.ThrowIfCancellationRequested();
+                    }
+
                     // service factory or validation failed, abort startup.
                     exceptions.Add(ex);
                     LogAndRethrow();
diff --git a/src/libraries/Microsoft.Extensions.Options/ref/Microsoft.Extensions.Options.cs b/src/libraries/Microsoft.Extensions.Options/ref/Microsoft.Extensions.Options.cs
index 70f856d1313cfb..1618851dc52682 100644
--- a/src/libraries/Microsoft.Extensions.Options/ref/Microsoft.Extensions.Options.cs
+++ b/src/libraries/Microsoft.Extensions.Options/ref/Microsoft.Extensions.Options.cs
@@ -145,10 +145,18 @@ public partial interface IStartupValidator
     {
         void Validate();
     }
+    public partial interface IAsyncStartupValidator
+    {
+        System.Threading.Tasks.Task ValidateAsync(System.Threading.CancellationToken cancellationToken = default);
+    }
     public partial interface IValidateOptions<TOptions> where TOptions : class
     {
         Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, TOptions options);
     }
+    public partial interface IAsyncValidateOptions<in TOptions> where TOptions : class
+    {
+        System.Threading.Tasks.Task<Microsoft.Extensions.Options.ValidateOptionsResult> ValidateAsync(string? name, TOptions options, System.Threading.CancellationToken cancellationToken = default);
+    }
     public static partial class Options
     {
         public static readonly string DefaultName;
@@ -184,6 +192,18 @@ public OptionsBuilder(Microsoft.Extensions.DependencyInjection.IServiceCollectio
         public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4>(System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, bool> validation, string failureMessage) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull where TDep4 : notnull { throw null; }
         public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4, TDep5>(System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, bool> validation) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull where TDep4 : notnull where TDep5 : notnull { throw null; }
         public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4, TDep5>(System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, bool> validation, string failureMessage) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull where TDep4 : notnull where TDep5 : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate(System.Func<TOptions, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation) { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate(System.Func<TOptions, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep>(System.Func<TOptions, TDep, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation) where TDep : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep>(System.Func<TOptions, TDep, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) where TDep : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2>(System.Func<TOptions, TDep1, TDep2, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation) where TDep1 : notnull where TDep2 : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2>(System.Func<TOptions, TDep1, TDep2, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) where TDep1 : notnull where TDep2 : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3>(System.Func<TOptions, TDep1, TDep2, TDep3, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3>(System.Func<TOptions, TDep1, TDep2, TDep3, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4>(System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull where TDep4 : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4>(System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull where TDep4 : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4, TDep5>(System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull where TDep4 : notnull where TDep5 : notnull { throw null; }
+        public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4, TDep5>(System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) where TDep1 : notnull where TDep2 : notnull where TDep3 : notnull where TDep4 : notnull where TDep5 : notnull { throw null; }
     }
     public partial class OptionsCache<[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] TOptions> : Microsoft.Extensions.Options.IOptionsMonitorCache<TOptions> where TOptions : class
     {
@@ -399,4 +419,67 @@ public ValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, TDep3
         public System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, bool> Validation { get { throw null; } }
         public Microsoft.Extensions.Options.ValidateOptionsResult Validate(string? name, TOptions options) { throw null; }
     }
+    public partial class AsyncValidateOptions<TOptions> : Microsoft.Extensions.Options.IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        public AsyncValidateOptions(string? name, System.Func<TOptions, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) { }
+        public string FailureMessage { get { throw null; } }
+        public string? Name { get { throw null; } }
+        public System.Func<TOptions, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> Validation { get { throw null; } }
+        public System.Threading.Tasks.Task<Microsoft.Extensions.Options.ValidateOptionsResult> ValidateAsync(string? name, TOptions options, System.Threading.CancellationToken cancellationToken = default) { throw null; }
+    }
+    public partial class AsyncValidateOptions<TOptions, TDep> : Microsoft.Extensions.Options.IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        public AsyncValidateOptions(string? name, TDep dependency, System.Func<TOptions, TDep, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) { }
+        public TDep Dependency { get { throw null; } }
+        public string FailureMessage { get { throw null; } }
+        public string? Name { get { throw null; } }
+        public System.Func<TOptions, TDep, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> Validation { get { throw null; } }
+        public System.Threading.Tasks.Task<Microsoft.Extensions.Options.ValidateOptionsResult> ValidateAsync(string? name, TOptions options, System.Threading.CancellationToken cancellationToken = default) { throw null; }
+    }
+    public partial class AsyncValidateOptions<TOptions, TDep1, TDep2> : Microsoft.Extensions.Options.IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        public AsyncValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, System.Func<TOptions, TDep1, TDep2, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) { }
+        public TDep1 Dependency1 { get { throw null; } }
+        public TDep2 Dependency2 { get { throw null; } }
+        public string FailureMessage { get { throw null; } }
+        public string? Name { get { throw null; } }
+        public System.Func<TOptions, TDep1, TDep2, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> Validation { get { throw null; } }
+        public System.Threading.Tasks.Task<Microsoft.Extensions.Options.ValidateOptionsResult> ValidateAsync(string? name, TOptions options, System.Threading.CancellationToken cancellationToken = default) { throw null; }
+    }
+    public partial class AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3> : Microsoft.Extensions.Options.IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        public AsyncValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, System.Func<TOptions, TDep1, TDep2, TDep3, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) { }
+        public TDep1 Dependency1 { get { throw null; } }
+        public TDep2 Dependency2 { get { throw null; } }
+        public TDep3 Dependency3 { get { throw null; } }
+        public string FailureMessage { get { throw null; } }
+        public string? Name { get { throw null; } }
+        public System.Func<TOptions, TDep1, TDep2, TDep3, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> Validation { get { throw null; } }
+        public System.Threading.Tasks.Task<Microsoft.Extensions.Options.ValidateOptionsResult> ValidateAsync(string? name, TOptions options, System.Threading.CancellationToken cancellationToken = default) { throw null; }
+    }
+    public partial class AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3, TDep4> : Microsoft.Extensions.Options.IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        public AsyncValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) { }
+        public TDep1 Dependency1 { get { throw null; } }
+        public TDep2 Dependency2 { get { throw null; } }
+        public TDep3 Dependency3 { get { throw null; } }
+        public TDep4 Dependency4 { get { throw null; } }
+        public string FailureMessage { get { throw null; } }
+        public string? Name { get { throw null; } }
+        public System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> Validation { get { throw null; } }
+        public System.Threading.Tasks.Task<Microsoft.Extensions.Options.ValidateOptionsResult> ValidateAsync(string? name, TOptions options, System.Threading.CancellationToken cancellationToken = default) { throw null; }
+    }
+    public partial class AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> : Microsoft.Extensions.Options.IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        public AsyncValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, TDep5 dependency5, System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> validation, string failureMessage) { }
+        public TDep1 Dependency1 { get { throw null; } }
+        public TDep2 Dependency2 { get { throw null; } }
+        public TDep3 Dependency3 { get { throw null; } }
+        public TDep4 Dependency4 { get { throw null; } }
+        public TDep5 Dependency5 { get { throw null; } }
+        public string FailureMessage { get { throw null; } }
+        public string? Name { get { throw null; } }
+        public System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> Validation { get { throw null; } }
+        public System.Threading.Tasks.Task<Microsoft.Extensions.Options.ValidateOptionsResult> ValidateAsync(string? name, TOptions options, System.Threading.CancellationToken cancellationToken = default) { throw null; }
+    }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options/src/AsyncValidateOptions.cs b/src/libraries/Microsoft.Extensions.Options/src/AsyncValidateOptions.cs
new file mode 100644
index 00000000000000..8dbdd76605ce20
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Options/src/AsyncValidateOptions.cs
@@ -0,0 +1,455 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Implementation of <see cref="IAsyncValidateOptions{TOptions}"/>.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to validate.</typeparam>
+    public class AsyncValidateOptions<TOptions> : IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="AsyncValidateOptions{TOptions}"/>.
+        /// </summary>
+        /// <param name="name">Options name.</param>
+        /// <param name="validation">Asynchronous validation function.</param>
+        /// <param name="failureMessage">Validation failure message.</param>
+        public AsyncValidateOptions(string? name, Func<TOptions, CancellationToken, Task<bool>> validation, string failureMessage)
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Name = name;
+            Validation = validation;
+            FailureMessage = failureMessage;
+        }
+
+        /// <summary>
+        /// Gets the options name.
+        /// </summary>
+        public string? Name { get; }
+
+        /// <summary>
+        /// Gets the asynchronous validation function.
+        /// </summary>
+        public Func<TOptions, CancellationToken, Task<bool>> Validation { get; }
+
+        /// <summary>
+        /// Gets the error to return when validation fails.
+        /// </summary>
+        public string FailureMessage { get; }
+
+        /// <summary>
+        /// Asynchronously validates a specific named options instance (or all when <paramref name="name"/> is null).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>The <see cref="ValidateOptionsResult"/> result.</returns>
+        public async Task<ValidateOptionsResult> ValidateAsync(string? name, TOptions options, CancellationToken cancellationToken = default)
+        {
+            // null name is used to configure all named options
+            if (Name is null || name == Name)
+            {
+                if (await Validation(options, cancellationToken).ConfigureAwait(false))
+                {
+                    return ValidateOptionsResult.Success;
+                }
+
+                return ValidateOptionsResult.Fail(FailureMessage);
+            }
+
+            // ignored if not validating this instance
+            return ValidateOptionsResult.Skip;
+        }
+    }
+
+    /// <summary>
+    /// Implementation of <see cref="IAsyncValidateOptions{TOptions}"/>.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to validate.</typeparam>
+    /// <typeparam name="TDep">Dependency type.</typeparam>
+    public class AsyncValidateOptions<TOptions, TDep> : IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="AsyncValidateOptions{TOptions, TDep}"/>.
+        /// </summary>
+        /// <param name="name">Options name.</param>
+        /// <param name="dependency">The dependency.</param>
+        /// <param name="validation">Asynchronous validation function.</param>
+        /// <param name="failureMessage">Validation failure message.</param>
+        public AsyncValidateOptions(string? name, TDep dependency, Func<TOptions, TDep, CancellationToken, Task<bool>> validation, string failureMessage)
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Name = name;
+            Dependency = dependency;
+            Validation = validation;
+            FailureMessage = failureMessage;
+        }
+
+        /// <summary>
+        /// Gets the options name.
+        /// </summary>
+        public string? Name { get; }
+
+        /// <summary>
+        /// Gets the dependency.
+        /// </summary>
+        public TDep Dependency { get; }
+
+        /// <summary>
+        /// Gets the asynchronous validation function.
+        /// </summary>
+        public Func<TOptions, TDep, CancellationToken, Task<bool>> Validation { get; }
+
+        /// <summary>
+        /// Gets the error to return when validation fails.
+        /// </summary>
+        public string FailureMessage { get; }
+
+        /// <inheritdoc/>
+        public async Task<ValidateOptionsResult> ValidateAsync(string? name, TOptions options, CancellationToken cancellationToken = default)
+        {
+            if (Name is null || name == Name)
+            {
+                if (await Validation(options, Dependency, cancellationToken).ConfigureAwait(false))
+                {
+                    return ValidateOptionsResult.Success;
+                }
+
+                return ValidateOptionsResult.Fail(FailureMessage);
+            }
+
+            return ValidateOptionsResult.Skip;
+        }
+    }
+
+    /// <summary>
+    /// Implementation of <see cref="IAsyncValidateOptions{TOptions}"/>.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to validate.</typeparam>
+    /// <typeparam name="TDep1">First dependency type.</typeparam>
+    /// <typeparam name="TDep2">Second dependency type.</typeparam>
+    public class AsyncValidateOptions<TOptions, TDep1, TDep2> : IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="AsyncValidateOptions{TOptions, TDep1, TDep2}"/>.
+        /// </summary>
+        /// <param name="name">Options name.</param>
+        /// <param name="dependency1">The first dependency.</param>
+        /// <param name="dependency2">The second dependency.</param>
+        /// <param name="validation">Asynchronous validation function.</param>
+        /// <param name="failureMessage">Validation failure message.</param>
+        public AsyncValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, Func<TOptions, TDep1, TDep2, CancellationToken, Task<bool>> validation, string failureMessage)
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Name = name;
+            Dependency1 = dependency1;
+            Dependency2 = dependency2;
+            Validation = validation;
+            FailureMessage = failureMessage;
+        }
+
+        /// <summary>
+        /// Gets the options name.
+        /// </summary>
+        public string? Name { get; }
+
+        /// <summary>
+        /// Gets the first dependency.
+        /// </summary>
+        public TDep1 Dependency1 { get; }
+
+        /// <summary>
+        /// Gets the second dependency.
+        /// </summary>
+        public TDep2 Dependency2 { get; }
+
+        /// <summary>
+        /// Gets the asynchronous validation function.
+        /// </summary>
+        public Func<TOptions, TDep1, TDep2, CancellationToken, Task<bool>> Validation { get; }
+
+        /// <summary>
+        /// Gets the error to return when validation fails.
+        /// </summary>
+        public string FailureMessage { get; }
+
+        /// <inheritdoc/>
+        public async Task<ValidateOptionsResult> ValidateAsync(string? name, TOptions options, CancellationToken cancellationToken = default)
+        {
+            if (Name is null || name == Name)
+            {
+                if (await Validation(options, Dependency1, Dependency2, cancellationToken).ConfigureAwait(false))
+                {
+                    return ValidateOptionsResult.Success;
+                }
+
+                return ValidateOptionsResult.Fail(FailureMessage);
+            }
+
+            return ValidateOptionsResult.Skip;
+        }
+    }
+
+    /// <summary>
+    /// Implementation of <see cref="IAsyncValidateOptions{TOptions}"/>.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to validate.</typeparam>
+    /// <typeparam name="TDep1">First dependency type.</typeparam>
+    /// <typeparam name="TDep2">Second dependency type.</typeparam>
+    /// <typeparam name="TDep3">Third dependency type.</typeparam>
+    public class AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3> : IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="AsyncValidateOptions{TOptions, TDep1, TDep2, TDep3}"/>.
+        /// </summary>
+        /// <param name="name">Options name.</param>
+        /// <param name="dependency1">The first dependency.</param>
+        /// <param name="dependency2">The second dependency.</param>
+        /// <param name="dependency3">The third dependency.</param>
+        /// <param name="validation">Asynchronous validation function.</param>
+        /// <param name="failureMessage">Validation failure message.</param>
+        public AsyncValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, Func<TOptions, TDep1, TDep2, TDep3, CancellationToken, Task<bool>> validation, string failureMessage)
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Name = name;
+            Dependency1 = dependency1;
+            Dependency2 = dependency2;
+            Dependency3 = dependency3;
+            Validation = validation;
+            FailureMessage = failureMessage;
+        }
+
+        /// <summary>
+        /// Gets the options name.
+        /// </summary>
+        public string? Name { get; }
+
+        /// <summary>
+        /// Gets the first dependency.
+        /// </summary>
+        public TDep1 Dependency1 { get; }
+
+        /// <summary>
+        /// Gets the second dependency.
+        /// </summary>
+        public TDep2 Dependency2 { get; }
+
+        /// <summary>
+        /// Gets the third dependency.
+        /// </summary>
+        public TDep3 Dependency3 { get; }
+
+        /// <summary>
+        /// Gets the asynchronous validation function.
+        /// </summary>
+        public Func<TOptions, TDep1, TDep2, TDep3, CancellationToken, Task<bool>> Validation { get; }
+
+        /// <summary>
+        /// Gets the error to return when validation fails.
+        /// </summary>
+        public string FailureMessage { get; }
+
+        /// <inheritdoc/>
+        public async Task<ValidateOptionsResult> ValidateAsync(string? name, TOptions options, CancellationToken cancellationToken = default)
+        {
+            if (Name is null || name == Name)
+            {
+                if (await Validation(options, Dependency1, Dependency2, Dependency3, cancellationToken).ConfigureAwait(false))
+                {
+                    return ValidateOptionsResult.Success;
+                }
+
+                return ValidateOptionsResult.Fail(FailureMessage);
+            }
+
+            return ValidateOptionsResult.Skip;
+        }
+    }
+
+    /// <summary>
+    /// Implementation of <see cref="IAsyncValidateOptions{TOptions}"/>.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to validate.</typeparam>
+    /// <typeparam name="TDep1">First dependency type.</typeparam>
+    /// <typeparam name="TDep2">Second dependency type.</typeparam>
+    /// <typeparam name="TDep3">Third dependency type.</typeparam>
+    /// <typeparam name="TDep4">Fourth dependency type.</typeparam>
+    public class AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3, TDep4> : IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="AsyncValidateOptions{TOptions, TDep1, TDep2, TDep3, TDep4}"/>.
+        /// </summary>
+        /// <param name="name">Options name.</param>
+        /// <param name="dependency1">The first dependency.</param>
+        /// <param name="dependency2">The second dependency.</param>
+        /// <param name="dependency3">The third dependency.</param>
+        /// <param name="dependency4">The fourth dependency.</param>
+        /// <param name="validation">Asynchronous validation function.</param>
+        /// <param name="failureMessage">Validation failure message.</param>
+        public AsyncValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, Func<TOptions, TDep1, TDep2, TDep3, TDep4, CancellationToken, Task<bool>> validation, string failureMessage)
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Name = name;
+            Dependency1 = dependency1;
+            Dependency2 = dependency2;
+            Dependency3 = dependency3;
+            Dependency4 = dependency4;
+            Validation = validation;
+            FailureMessage = failureMessage;
+        }
+
+        /// <summary>
+        /// Gets the options name.
+        /// </summary>
+        public string? Name { get; }
+
+        /// <summary>
+        /// Gets the first dependency.
+        /// </summary>
+        public TDep1 Dependency1 { get; }
+
+        /// <summary>
+        /// Gets the second dependency.
+        /// </summary>
+        public TDep2 Dependency2 { get; }
+
+        /// <summary>
+        /// Gets the third dependency.
+        /// </summary>
+        public TDep3 Dependency3 { get; }
+
+        /// <summary>
+        /// Gets the fourth dependency.
+        /// </summary>
+        public TDep4 Dependency4 { get; }
+
+        /// <summary>
+        /// Gets the asynchronous validation function.
+        /// </summary>
+        public Func<TOptions, TDep1, TDep2, TDep3, TDep4, CancellationToken, Task<bool>> Validation { get; }
+
+        /// <summary>
+        /// Gets the error to return when validation fails.
+        /// </summary>
+        public string FailureMessage { get; }
+
+        /// <inheritdoc/>
+        public async Task<ValidateOptionsResult> ValidateAsync(string? name, TOptions options, CancellationToken cancellationToken = default)
+        {
+            if (Name is null || name == Name)
+            {
+                if (await Validation(options, Dependency1, Dependency2, Dependency3, Dependency4, cancellationToken).ConfigureAwait(false))
+                {
+                    return ValidateOptionsResult.Success;
+                }
+
+                return ValidateOptionsResult.Fail(FailureMessage);
+            }
+
+            return ValidateOptionsResult.Skip;
+        }
+    }
+
+    /// <summary>
+    /// Implementation of <see cref="IAsyncValidateOptions{TOptions}"/>.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to validate.</typeparam>
+    /// <typeparam name="TDep1">First dependency type.</typeparam>
+    /// <typeparam name="TDep2">Second dependency type.</typeparam>
+    /// <typeparam name="TDep3">Third dependency type.</typeparam>
+    /// <typeparam name="TDep4">Fourth dependency type.</typeparam>
+    /// <typeparam name="TDep5">Fifth dependency type.</typeparam>
+    public class AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> : IAsyncValidateOptions<TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="AsyncValidateOptions{TOptions, TDep1, TDep2, TDep3, TDep4, TDep5}"/>.
+        /// </summary>
+        /// <param name="name">Options name.</param>
+        /// <param name="dependency1">The first dependency.</param>
+        /// <param name="dependency2">The second dependency.</param>
+        /// <param name="dependency3">The third dependency.</param>
+        /// <param name="dependency4">The fourth dependency.</param>
+        /// <param name="dependency5">The fifth dependency.</param>
+        /// <param name="validation">Asynchronous validation function.</param>
+        /// <param name="failureMessage">Validation failure message.</param>
+        public AsyncValidateOptions(string? name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, TDep5 dependency5, Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, CancellationToken, Task<bool>> validation, string failureMessage)
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Name = name;
+            Dependency1 = dependency1;
+            Dependency2 = dependency2;
+            Dependency3 = dependency3;
+            Dependency4 = dependency4;
+            Dependency5 = dependency5;
+            Validation = validation;
+            FailureMessage = failureMessage;
+        }
+
+        /// <summary>
+        /// Gets the options name.
+        /// </summary>
+        public string? Name { get; }
+
+        /// <summary>
+        /// Gets the first dependency.
+        /// </summary>
+        public TDep1 Dependency1 { get; }
+
+        /// <summary>
+        /// Gets the second dependency.
+        /// </summary>
+        public TDep2 Dependency2 { get; }
+
+        /// <summary>
+        /// Gets the third dependency.
+        /// </summary>
+        public TDep3 Dependency3 { get; }
+
+        /// <summary>
+        /// Gets the fourth dependency.
+        /// </summary>
+        public TDep4 Dependency4 { get; }
+
+        /// <summary>
+        /// Gets the fifth dependency.
+        /// </summary>
+        public TDep5 Dependency5 { get; }
+
+        /// <summary>
+        /// Gets the asynchronous validation function.
+        /// </summary>
+        public Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, CancellationToken, Task<bool>> Validation { get; }
+
+        /// <summary>
+        /// Gets the error to return when validation fails.
+        /// </summary>
+        public string FailureMessage { get; }
+
+        /// <inheritdoc/>
+        public async Task<ValidateOptionsResult> ValidateAsync(string? name, TOptions options, CancellationToken cancellationToken = default)
+        {
+            if (Name is null || name == Name)
+            {
+                if (await Validation(options, Dependency1, Dependency2, Dependency3, Dependency4, Dependency5, cancellationToken).ConfigureAwait(false))
+                {
+                    return ValidateOptionsResult.Success;
+                }
+
+                return ValidateOptionsResult.Fail(FailureMessage);
+            }
+
+            return ValidateOptionsResult.Skip;
+        }
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Options/src/IAsyncStartupValidator.cs b/src/libraries/Microsoft.Extensions.Options/src/IAsyncStartupValidator.cs
new file mode 100644
index 00000000000000..93267ec699c346
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Options/src/IAsyncStartupValidator.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Used by hosts to asynchronously validate options during startup.
+    /// </summary>
+    public interface IAsyncStartupValidator
+    {
+        /// <summary>
+        /// Calls all registered <see cref="IAsyncValidateOptions{TOptions}"/> validators.
+        /// </summary>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="OptionsValidationException">
+        /// A single validator returns a failed <see cref="ValidateOptionsResult"/> when validating.
+        /// </exception>
+        /// <exception cref="System.AggregateException">
+        /// Multiple validators return failed <see cref="ValidateOptionsResult"/> results when validating.
+        /// </exception>
+        Task ValidateAsync(CancellationToken cancellationToken = default);
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Options/src/IAsyncValidateOptions.cs b/src/libraries/Microsoft.Extensions.Options/src/IAsyncValidateOptions.cs
new file mode 100644
index 00000000000000..66caef599340b1
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Options/src/IAsyncValidateOptions.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Extensions.Options
+{
+    /// <summary>
+    /// Asynchronously validates options.
+    /// </summary>
+    /// <typeparam name="TOptions">The options type to validate.</typeparam>
+    public interface IAsyncValidateOptions<in TOptions> where TOptions : class
+    {
+        /// <summary>
+        /// Asynchronously validates a specified named options instance (or all if <paramref name="name"/> is <see langword="null"/>).
+        /// </summary>
+        /// <param name="name">The name of the options instance being validated.</param>
+        /// <param name="options">The options instance.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>The <see cref="ValidateOptionsResult"/> result.</returns>
+        Task<ValidateOptionsResult> ValidateAsync(string? name, TOptions options, CancellationToken cancellationToken = default);
+    }
+}
diff --git a/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilder.cs b/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilder.cs
index a007a45a0fb7ea..3f7b914bf81ee9 100644
--- a/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilder.cs
+++ b/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilder.cs
@@ -3,6 +3,8 @@
 
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.Extensions.Options
@@ -570,5 +572,222 @@ public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4, TDe
                     failureMessage));
             return this;
         }
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type using a default failure message.
+        /// </summary>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate(Func<TOptions, CancellationToken, Task<bool>> validation)
+            => Validate(validation: validation, failureMessage: DefaultValidationFailureMessage);
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type.
+        /// </summary>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <param name="failureMessage">The failure message to use when validation fails.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate(Func<TOptions, CancellationToken, Task<bool>> validation, string failureMessage)
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Services.AddSingleton<IAsyncValidateOptions<TOptions>>(new AsyncValidateOptions<TOptions>(Name, validation, failureMessage));
+            return this;
+        }
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type using a default failure message.
+        /// </summary>
+        /// <typeparam name="TDep">The dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep>(Func<TOptions, TDep, CancellationToken, Task<bool>> validation) where TDep : notnull
+            => Validate(validation: validation, failureMessage: DefaultValidationFailureMessage);
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type.
+        /// </summary>
+        /// <typeparam name="TDep">The dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <param name="failureMessage">The failure message to use when validation fails.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep>(Func<TOptions, TDep, CancellationToken, Task<bool>> validation, string failureMessage) where TDep : notnull
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Services.AddTransient<IAsyncValidateOptions<TOptions>>(sp =>
+                new AsyncValidateOptions<TOptions, TDep>(Name, sp.GetRequiredService<TDep>(), validation, failureMessage));
+            return this;
+        }
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type using a default failure message.
+        /// </summary>
+        /// <typeparam name="TDep1">The first dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep2">The second dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2>(Func<TOptions, TDep1, TDep2, CancellationToken, Task<bool>> validation)
+            where TDep1 : notnull
+            where TDep2 : notnull
+            => Validate(validation: validation, failureMessage: DefaultValidationFailureMessage);
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type.
+        /// </summary>
+        /// <typeparam name="TDep1">The first dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep2">The second dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <param name="failureMessage">The failure message to use when validation fails.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2>(Func<TOptions, TDep1, TDep2, CancellationToken, Task<bool>> validation, string failureMessage)
+            where TDep1 : notnull
+            where TDep2 : notnull
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Services.AddTransient<IAsyncValidateOptions<TOptions>>(sp =>
+                new AsyncValidateOptions<TOptions, TDep1, TDep2>(Name,
+                    sp.GetRequiredService<TDep1>(),
+                    sp.GetRequiredService<TDep2>(),
+                    validation,
+                    failureMessage));
+            return this;
+        }
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type using a default failure message.
+        /// </summary>
+        /// <typeparam name="TDep1">The first dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep2">The second dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep3">The third dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3>(Func<TOptions, TDep1, TDep2, TDep3, CancellationToken, Task<bool>> validation)
+            where TDep1 : notnull
+            where TDep2 : notnull
+            where TDep3 : notnull
+            => Validate(validation: validation, failureMessage: DefaultValidationFailureMessage);
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type.
+        /// </summary>
+        /// <typeparam name="TDep1">The first dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep2">The second dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep3">The third dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <param name="failureMessage">The failure message to use when validation fails.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3>(Func<TOptions, TDep1, TDep2, TDep3, CancellationToken, Task<bool>> validation, string failureMessage)
+            where TDep1 : notnull
+            where TDep2 : notnull
+            where TDep3 : notnull
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Services.AddTransient<IAsyncValidateOptions<TOptions>>(sp =>
+                new AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3>(Name,
+                    sp.GetRequiredService<TDep1>(),
+                    sp.GetRequiredService<TDep2>(),
+                    sp.GetRequiredService<TDep3>(),
+                    validation,
+                    failureMessage));
+            return this;
+        }
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type using a default failure message.
+        /// </summary>
+        /// <typeparam name="TDep1">The first dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep2">The second dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep3">The third dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep4">The fourth dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4>(Func<TOptions, TDep1, TDep2, TDep3, TDep4, CancellationToken, Task<bool>> validation)
+            where TDep1 : notnull
+            where TDep2 : notnull
+            where TDep3 : notnull
+            where TDep4 : notnull
+            => Validate(validation: validation, failureMessage: DefaultValidationFailureMessage);
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type.
+        /// </summary>
+        /// <typeparam name="TDep1">The first dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep2">The second dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep3">The third dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep4">The fourth dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <param name="failureMessage">The failure message to use when validation fails.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4>(Func<TOptions, TDep1, TDep2, TDep3, TDep4, CancellationToken, Task<bool>> validation, string failureMessage)
+            where TDep1 : notnull
+            where TDep2 : notnull
+            where TDep3 : notnull
+            where TDep4 : notnull
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Services.AddTransient<IAsyncValidateOptions<TOptions>>(sp =>
+                new AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3, TDep4>(Name,
+                    sp.GetRequiredService<TDep1>(),
+                    sp.GetRequiredService<TDep2>(),
+                    sp.GetRequiredService<TDep3>(),
+                    sp.GetRequiredService<TDep4>(),
+                    validation,
+                    failureMessage));
+            return this;
+        }
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type using a default failure message.
+        /// </summary>
+        /// <typeparam name="TDep1">The first dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep2">The second dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep3">The third dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep4">The fourth dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep5">The fifth dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4, TDep5>(Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, CancellationToken, Task<bool>> validation)
+            where TDep1 : notnull
+            where TDep2 : notnull
+            where TDep3 : notnull
+            where TDep4 : notnull
+            where TDep5 : notnull
+            => Validate(validation: validation, failureMessage: DefaultValidationFailureMessage);
+
+        /// <summary>
+        /// Registers an asynchronous validation action for an options type.
+        /// </summary>
+        /// <typeparam name="TDep1">The first dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep2">The second dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep3">The third dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep4">The fourth dependency used by the validation function.</typeparam>
+        /// <typeparam name="TDep5">The fifth dependency used by the validation function.</typeparam>
+        /// <param name="validation">The asynchronous validation function.</param>
+        /// <param name="failureMessage">The failure message to use when validation fails.</param>
+        /// <returns>The current <see cref="OptionsBuilder{TOptions}"/>.</returns>
+        public virtual OptionsBuilder<TOptions> Validate<TDep1, TDep2, TDep3, TDep4, TDep5>(Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, CancellationToken, Task<bool>> validation, string failureMessage)
+            where TDep1 : notnull
+            where TDep2 : notnull
+            where TDep3 : notnull
+            where TDep4 : notnull
+            where TDep5 : notnull
+        {
+            ArgumentNullException.ThrowIfNull(validation);
+
+            Services.AddTransient<IAsyncValidateOptions<TOptions>>(sp =>
+                new AsyncValidateOptions<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5>(Name,
+                    sp.GetRequiredService<TDep1>(),
+                    sp.GetRequiredService<TDep2>(),
+                    sp.GetRequiredService<TDep3>(),
+                    sp.GetRequiredService<TDep4>(),
+                    sp.GetRequiredService<TDep5>(),
+                    validation,
+                    failureMessage));
+            return this;
+        }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilderExtensions.cs b/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilderExtensions.cs
index e893e9e6851da9..205adb41022949 100644
--- a/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilderExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilderExtensions.cs
@@ -2,7 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Options;
 
@@ -25,6 +28,7 @@ public static class OptionsBuilderExtensions
             ArgumentNullException.ThrowIfNull(optionsBuilder);
 
             optionsBuilder.Services.TryAddTransient<IStartupValidator, StartupValidator>();
+            optionsBuilder.Services.TryAddTransient<IAsyncStartupValidator, StartupValidator>();
             optionsBuilder.Services.AddOptions<StartupValidatorOptions>()
                 .Configure<IOptionsMonitor<TOptions>>((vo, options) =>
                 {
@@ -33,6 +37,39 @@ public static class OptionsBuilderExtensions
                     vo._validators[(typeof(TOptions), optionsBuilder.Name)] = () => options.Get(optionsBuilder.Name);
                 });
 
+            // Register async validator entries if any IAsyncValidateOptions<TOptions> are registered
+            optionsBuilder.Services.AddOptions<StartupValidatorOptions>()
+                .Configure<IOptionsMonitor<TOptions>, IEnumerable<IAsyncValidateOptions<TOptions>>>((vo, options, asyncValidators) =>
+                {
+                    // Materialize the validators into a list to check if any are registered
+                    var validators = new List<IAsyncValidateOptions<TOptions>>(asyncValidators);
+                    if (validators.Count > 0)
+                    {
+                        vo._asyncValidators[(typeof(TOptions), optionsBuilder.Name)] = async (CancellationToken ct) =>
+                        {
+                            // Retrieve the options value (already created by sync Validate() call)
+                            TOptions optionsValue = options.Get(optionsBuilder.Name);
+
+                            // Run async validators
+                            List<string>? failures = null;
+                            foreach (IAsyncValidateOptions<TOptions> validator in validators)
+                            {
+                                ValidateOptionsResult result = await validator.ValidateAsync(optionsBuilder.Name, optionsValue, ct).ConfigureAwait(false);
+                                if (result is not null && result.Failed)
+                                {
+                                    failures ??= new List<string>();
+                                    failures.AddRange(result.Failures);
+                                }
+                            }
+
+                            if (failures is not null && failures.Count > 0)
+                            {
+                                throw new OptionsValidationException(optionsBuilder.Name, typeof(TOptions), failures);
+                            }
+                        };
+                    }
+                });
+
             return optionsBuilder;
         }
     }
diff --git a/src/libraries/Microsoft.Extensions.Options/src/StartupValidatorOptions.cs b/src/libraries/Microsoft.Extensions.Options/src/StartupValidatorOptions.cs
index d1186f121dcf78..7dbb192de4858d 100644
--- a/src/libraries/Microsoft.Extensions.Options/src/StartupValidatorOptions.cs
+++ b/src/libraries/Microsoft.Extensions.Options/src/StartupValidatorOptions.cs
@@ -3,6 +3,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Microsoft.Extensions.Options
 {
@@ -10,5 +12,8 @@ internal sealed class StartupValidatorOptions
     {
         // Maps each pair of a) options type and b) options name to a method that forces its evaluation, e.g. IOptionsMonitor<TOptions>.Get(name)
         public Dictionary<(Type, string), Action> _validators { get; } = new Dictionary<(Type, string), Action>();
+
+        // Maps each pair of a) options type and b) options name to an async method that forces evaluation and runs async validators
+        public Dictionary<(Type, string), Func<CancellationToken, Task>> _asyncValidators { get; } = new Dictionary<(Type, string), Func<CancellationToken, Task>>();
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options/src/ValidateOnStart.cs b/src/libraries/Microsoft.Extensions.Options/src/ValidateOnStart.cs
index d2e972974edcf3..6a611700c090fa 100644
--- a/src/libraries/Microsoft.Extensions.Options/src/ValidateOnStart.cs
+++ b/src/libraries/Microsoft.Extensions.Options/src/ValidateOnStart.cs
@@ -4,11 +4,13 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.ExceptionServices;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Options;
 
 namespace Microsoft.Extensions.Options
 {
-    internal sealed class StartupValidator : IStartupValidator
+    internal sealed class StartupValidator : IStartupValidator, IAsyncStartupValidator
     {
         private readonly StartupValidatorOptions _validatorOptions;
 
@@ -50,5 +52,38 @@ public void Validate()
                 }
             }
         }
+
+        public async Task ValidateAsync(CancellationToken cancellationToken = default)
+        {
+            // Async validators only — sync validation is handled separately by
+            // IStartupValidator.Validate() in Host.StartAsync() (two-stage orchestration).
+            List<Exception>? exceptions = null;
+
+            foreach (Func<CancellationToken, Task> asyncValidator in _validatorOptions._asyncValidators.Values)
+            {
+                try
+                {
+                    await asyncValidator(cancellationToken).ConfigureAwait(false);
+                }
+                catch (OptionsValidationException ex)
+                {
+                    exceptions ??= new();
+                    exceptions.Add(ex);
+                }
+            }
+
+            if (exceptions is not null)
+            {
+                if (exceptions.Count == 1)
+                {
+                    ExceptionDispatchInfo.Capture(exceptions[0]).Throw();
+                }
+
+                if (exceptions.Count > 1)
+                {
+                    throw new AggregateException(exceptions);
+                }
+            }
+        }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/AsyncOptionsValidationTests.cs b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/AsyncOptionsValidationTests.cs
new file mode 100644
index 00000000000000..b8e514550f546a
--- /dev/null
+++ b/src/libraries/Microsoft.Extensions.Options/tests/Microsoft.Extensions.Options.Tests/AsyncOptionsValidationTests.cs
@@ -0,0 +1,248 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Microsoft.Extensions.Options.Tests
+{
+    public class AsyncOptionsValidationTests
+    {
+        [Fact]
+        public async Task AsyncValidateOptions_SkipsWhenNameDoesNotMatch()
+        {
+            var validator = new AsyncValidateOptions<FakeOptions>(
+                "expected",
+                (options, ct) => Task.FromResult(false),
+                "Should not run");
+
+            ValidateOptionsResult result = await validator.ValidateAsync("other", new FakeOptions(), CancellationToken.None);
+
+            Assert.True(result.Skipped);
+        }
+
+        [Fact]
+        public async Task AsyncValidateOptions_ValidatesWhenNameMatches()
+        {
+            var validator = new AsyncValidateOptions<FakeOptions>(
+                "expected",
+                (options, ct) => Task.FromResult(false),
+                "Validation failed");
+
+            ValidateOptionsResult result = await validator.ValidateAsync("expected", new FakeOptions(), CancellationToken.None);
+
+            Assert.True(result.Failed);
+            Assert.Contains("Validation failed", result.Failures);
+        }
+
+        [Fact]
+        public async Task AsyncValidateOptions_ValidatesAllWhenNameIsNull()
+        {
+            var validator = new AsyncValidateOptions<FakeOptions>(
+                null,
+                (options, ct) => Task.FromResult(true),
+                "fail");
+
+            ValidateOptionsResult result = await validator.ValidateAsync("any-name", new FakeOptions(), CancellationToken.None);
+
+            Assert.True(result.Succeeded);
+        }
+
+        [Fact]
+        public async Task OptionsBuilder_AsyncValidate_RegistersAndExecutes()
+        {
+            var services = new ServiceCollection();
+            bool asyncRan = false;
+
+            services.AddOptions<FakeOptions>()
+                .Configure(o => o.Message = "test")
+                .Validate(async (FakeOptions o, CancellationToken ct) =>
+                {
+                    asyncRan = true;
+                    return await Task.FromResult(true);
+                }, "async fail")
+                .ValidateOnStart();
+
+            ServiceProvider sp = services.BuildServiceProvider();
+            var validator = sp.GetRequiredService<IAsyncStartupValidator>();
+
+            await validator.ValidateAsync(CancellationToken.None);
+
+            Assert.True(asyncRan);
+        }
+
+        [Fact]
+        public async Task StartupValidator_TwoStage_RunsBothSyncAndAsyncValidators()
+        {
+            var services = new ServiceCollection();
+            bool syncRan = false;
+            bool asyncRan = false;
+
+            services.AddOptions<FakeOptions>()
+                .Configure(o => o.Message = "test")
+                .Validate(o => { syncRan = true; return true; }, "sync fail")
+                .Validate(async (FakeOptions o, CancellationToken ct) =>
+                {
+                    asyncRan = true;
+                    return await Task.FromResult(true);
+                }, "async fail")
+                .ValidateOnStart();
+
+            ServiceProvider sp = services.BuildServiceProvider();
+
+            // Two-stage orchestration: Host.cs calls Validate() then ValidateAsync() independently
+            var syncValidator = sp.GetRequiredService<IStartupValidator>();
+            syncValidator.Validate();
+            Assert.True(syncRan);
+
+            var asyncValidator = sp.GetRequiredService<IAsyncStartupValidator>();
+            await asyncValidator.ValidateAsync(CancellationToken.None);
+            Assert.True(asyncRan);
+        }
+
+        [Fact]
+        public async Task StartupValidator_TwoStage_SyncFailureSkipsAsyncValidators()
+        {
+            var services = new ServiceCollection();
+            bool asyncRan = false;
+
+            services.AddOptions<FakeOptions>()
+                .Configure(o => o.Message = "test")
+                .Validate(o => false, "sync validation failed")
+                .Validate(async (FakeOptions o, CancellationToken ct) =>
+                {
+                    asyncRan = true;
+                    return await Task.FromResult(true);
+                }, "async")
+                .ValidateOnStart();
+
+            ServiceProvider sp = services.BuildServiceProvider();
+
+            // Stage 1: Sync throws — in Host.cs, this prevents reaching Stage 2
+            var syncValidator = sp.GetRequiredService<IStartupValidator>();
+            Assert.Throws<OptionsValidationException>(() => syncValidator.Validate());
+
+            // Stage 2 is never reached because the exception propagates.
+            // Verify async didn't run (simulating Host.cs short-circuit behavior).
+            Assert.False(asyncRan);
+        }
+
+        [Fact]
+        public async Task StartupValidator_ValidateAsync_OnlyAsyncValidators()
+        {
+            var services = new ServiceCollection();
+            bool asyncRan = false;
+
+            services.AddOptions<FakeOptions>()
+                .Configure(o => o.Message = "test")
+                .Validate(async (FakeOptions o, CancellationToken ct) =>
+                {
+                    asyncRan = true;
+                    return await Task.FromResult(true);
+                }, "async fail")
+                .ValidateOnStart();
+
+            ServiceProvider sp = services.BuildServiceProvider();
+            var validator = sp.GetRequiredService<IAsyncStartupValidator>();
+
+            await validator.ValidateAsync(CancellationToken.None);
+
+            Assert.True(asyncRan);
+        }
+
+        [Fact]
+        public async Task StartupValidator_ValidateAsync_AsyncFailureThrowsOptionsValidationException()
+        {
+            var services = new ServiceCollection();
+
+            services.AddOptions<FakeOptions>()
+                .Configure(o => o.Message = "test")
+                .Validate(async (FakeOptions o, CancellationToken ct) =>
+                {
+                    await Task.CompletedTask;
+                    return false;
+                }, "async validation failed")
+                .ValidateOnStart();
+
+            ServiceProvider sp = services.BuildServiceProvider();
+            var validator = sp.GetRequiredService<IAsyncStartupValidator>();
+
+            OptionsValidationException ex = await Assert.ThrowsAsync<OptionsValidationException>(
+                () => validator.ValidateAsync(CancellationToken.None));
+            Assert.Contains("async validation failed", ex.Failures);
+        }
+
+        [Fact]
+        public async Task ValidateOnStart_CustomSyncOnlyValidator_DoesNotThrowInvalidCast()
+        {
+            var services = new ServiceCollection();
+
+            // Register a custom IStartupValidator that does NOT implement IAsyncStartupValidator
+            services.AddSingleton<IStartupValidator>(new CustomSyncOnlyValidator());
+
+            services.AddOptions<FakeOptions>()
+                .Configure(o => o.Message = "test")
+                .Validate(async (FakeOptions o, CancellationToken ct) => await Task.FromResult(true), "async")
+                .ValidateOnStart();
+
+            ServiceProvider sp = services.BuildServiceProvider();
+
+            // Should NOT throw InvalidCastException — IAsyncStartupValidator gets its own StartupValidator instance
+            var asyncValidator = sp.GetRequiredService<IAsyncStartupValidator>();
+            await asyncValidator.ValidateAsync(CancellationToken.None);
+        }
+
+        [Fact]
+        public async Task StartupValidator_ValidateAsync_CancellationTokenPropagated()
+        {
+            var services = new ServiceCollection();
+            using var cts = new CancellationTokenSource();
+
+            services.AddOptions<FakeOptions>()
+                .Configure(o => o.Message = "test")
+                .Validate(async (FakeOptions o, CancellationToken ct) =>
+                {
+                    ct.ThrowIfCancellationRequested();
+                    return await Task.FromResult(true);
+                }, "async")
+                .ValidateOnStart();
+
+            ServiceProvider sp = services.BuildServiceProvider();
+            var validator = sp.GetRequiredService<IAsyncStartupValidator>();
+
+            cts.Cancel();
+            await Assert.ThrowsAsync<OperationCanceledException>(() => validator.ValidateAsync(cts.Token));
+        }
+
+        [Theory]
+        [InlineData("named1")]
+        [InlineData(null)]
+        public async Task AsyncValidateOptions_NameMatching_DefaultAndNamed(string? registeredName)
+        {
+            var validator = new AsyncValidateOptions<FakeOptions>(
+                registeredName,
+                (options, ct) => Task.FromResult(false),
+                "fail");
+
+            ValidateOptionsResult defaultResult = await validator.ValidateAsync(Options.DefaultName, new FakeOptions(), CancellationToken.None);
+
+            if (registeredName is null)
+            {
+                Assert.True(defaultResult.Failed);
+            }
+            else
+            {
+                Assert.True(defaultResult.Skipped);
+            }
+        }
+
+        private class CustomSyncOnlyValidator : IStartupValidator
+        {
+            public void Validate() { }
+        }
+    }
+}
diff --git a/src/libraries/System.ComponentModel.Annotations/src/System.ComponentModel.Annotations.csproj b/src/libraries/System.ComponentModel.Annotations/src/System.ComponentModel.Annotations.csproj
index 86cc5aaee55380..17cc6178d33579 100644
--- a/src/libraries/System.ComponentModel.Annotations/src/System.ComponentModel.Annotations.csproj
+++ b/src/libraries/System.ComponentModel.Annotations/src/System.ComponentModel.Annotations.csproj
@@ -14,8 +14,8 @@
     <Compile Include="System\ComponentModel\DataAnnotations\AllowedValuesAttribute.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\AssociatedMetadataTypeTypeDescriptor.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\AssociatedMetadataTypeTypeDescriptionProvider.cs" />
-    <Compile Include="System\ComponentModel\DataAnnotations\AssociationAttribute.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\AsyncValidationAttribute.cs" />
+    <Compile Include="System\ComponentModel\DataAnnotations\AssociationAttribute.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\Base64StringAttribute.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\CompareAttribute.cs" />
     <Compile Include="System\ComponentModel\DataAnnotations\ConcurrencyCheckAttribute.cs" />