diff --git a/AspNetCore.sln b/AspNetCore.sln
index 849a91e6cc85..6d7ea1b65c28 100644
--- a/AspNetCore.sln
+++ b/AspNetCore.sln
@@ -1,4 +1,3 @@
-
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.0.31606.5
@@ -1736,6 +1735,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "CustomElements", "CustomEle
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Templates.Blazor.WebAssembly.Tests", "src\ProjectTemplates\test\Templates.Blazor.WebAssembly.Tests\Templates.Blazor.WebAssembly.Tests.csproj", "{7CA0A9AF-9088-471C-B0B6-EBF43F21D3B9}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RateLimitingSample", "src\Middleware\RateLimiting\samples\RateLimitingSample\RateLimitingSample.csproj", "{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -10497,6 +10498,22 @@ Global
 		{7CA0A9AF-9088-471C-B0B6-EBF43F21D3B9}.Release|x64.Build.0 = Release|Any CPU
 		{7CA0A9AF-9088-471C-B0B6-EBF43F21D3B9}.Release|x86.ActiveCfg = Release|Any CPU
 		{7CA0A9AF-9088-471C-B0B6-EBF43F21D3B9}.Release|x86.Build.0 = Release|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Debug|arm64.ActiveCfg = Debug|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Debug|arm64.Build.0 = Debug|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Debug|x64.Build.0 = Debug|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Debug|x86.Build.0 = Debug|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Release|arm64.ActiveCfg = Release|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Release|arm64.Build.0 = Release|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Release|x64.ActiveCfg = Release|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Release|x64.Build.0 = Release|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Release|x86.ActiveCfg = Release|Any CPU
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -11365,6 +11382,7 @@ Global
 		{76C3E22D-092B-4E8A-81F0-DCF071BFF4CD} = {0BB58FB6-8B66-4C6D-BA8A-DF3AFAF9AB8F}
 		{0BB58FB6-8B66-4C6D-BA8A-DF3AFAF9AB8F} = {60D51C98-2CC0-40DF-B338-44154EFEE2FF}
 		{7CA0A9AF-9088-471C-B0B6-EBF43F21D3B9} = {08D53E58-4AAE-40C4-8497-63EC8664F304}
+		{91C3C03E-EA56-4ABA-9E73-A3DA4C2833D9} = {1D865E78-7A66-4CA9-92EE-2B350E45281F}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {3E8720B3-DBDD-498C-B383-2CC32A054E8F}
diff --git a/eng/Versions.props b/eng/Versions.props
index 9d9ff1e20b2f..8eec15b476bc 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -50,6 +50,8 @@
     <UsingToolNetFrameworkReferenceAssemblies Condition="'$(OS)' != 'Windows_NT'">true</UsingToolNetFrameworkReferenceAssemblies>
     <!-- Disable XLIFF tasks -->
     <UsingToolXliff>false</UsingToolXliff>
+    <!-- Use custom version of Roslyn Compiler -->
+    <UsingToolMicrosoftNetCompilers>true</UsingToolMicrosoftNetCompilers>
   </PropertyGroup>
   <!--
 
@@ -194,6 +196,10 @@
       framework in current .NET SDKs.
     -->
     <MicrosoftNETTestSdkVersion>17.1.0-preview-20211109-03</MicrosoftNETTestSdkVersion>
+    <!--
+      Use a compiler new enough to use required keyword
+    -->
+    <MicrosoftNetCompilersToolsetVersion>4.4.0-1.22358.14</MicrosoftNetCompilersToolsetVersion>
     <!--
       Versions of Microsoft.CodeAnalysis packages referenced by analyzers shipped in the SDK.
       This need to be pinned since they're used in 3.1 apps and need to be loadable in VS 2019.
diff --git a/src/Middleware/Middleware.slnf b/src/Middleware/Middleware.slnf
index c75854876fbf..c71da8528b7a 100644
--- a/src/Middleware/Middleware.slnf
+++ b/src/Middleware/Middleware.slnf
@@ -80,6 +80,7 @@
       "src\\Middleware\\OutputCaching\\src\\Microsoft.AspNetCore.OutputCaching.csproj",
       "src\\Middleware\\OutputCaching\\test\\Microsoft.AspNetCore.OutputCaching.Tests.csproj",
       "src\\Middleware\\RateLimiting\\src\\Microsoft.AspNetCore.RateLimiting.csproj",
+      "src\\Middleware\\RateLimiting\\samples\\RateLimitingSample\\RateLimitingSample.csproj",
       "src\\Middleware\\RateLimiting\\test\\Microsoft.AspNetCore.RateLimiting.Tests.csproj",
       "src\\Middleware\\RequestDecompression\\perf\\Microbenchmarks\\Microsoft.AspNetCore.RequestDecompression.Microbenchmarks.csproj",
       "src\\Middleware\\RequestDecompression\\sample\\RequestDecompressionSample.csproj",
diff --git a/src/Middleware/RateLimiting/samples/RateLimitingSample/Program.cs b/src/Middleware/RateLimiting/samples/RateLimitingSample/Program.cs
new file mode 100644
index 000000000000..0a13c89566ac
--- /dev/null
+++ b/src/Middleware/RateLimiting/samples/RateLimitingSample/Program.cs
@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.EntityFrameworkCore;
+using System.Threading.RateLimiting;
+using Microsoft.AspNetCore.RateLimiting;
+using RateLimitingSample;
+using Microsoft.Extensions.Logging.Abstractions;
+
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddDbContext<TodoDb>(opt => opt.UseInMemoryDatabase("TodoList"));
+builder.Services.AddDatabaseDeveloperPageExceptionFilter();
+// Inject an ILogger<SampleRateLimiterPolicy>
+builder.Services.AddLogging();
+
+var app = builder.Build();
+
+var todoName = "todoPolicy";
+var completeName = "completePolicy";
+var helloName = "helloPolicy";
+
+// Define endpoint limiters and a global limiter.
+var options = new RateLimiterOptions()
+        .AddTokenBucketLimiter(todoName, new TokenBucketRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 1, TimeSpan.FromSeconds(10), 1))
+        .AddPolicy<string>(completeName, new SampleRateLimiterPolicy(NullLogger<SampleRateLimiterPolicy>.Instance))
+        .AddPolicy<string, SampleRateLimiterPolicy>(helloName);
+// The global limiter will be a concurrency limiter with a max permit count of 10 and a queue depth of 5.
+options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(context =>
+        {
+            return RateLimitPartition.CreateConcurrencyLimiter<string>("globalLimiter", key => new ConcurrencyLimiterOptions(10, QueueProcessingOrder.NewestFirst, 5));
+        });
+app.UseRateLimiter(options);
+
+// The limiter on this endpoint allows 1 request every 5 seconds
+app.MapGet("/", () => "Hello World!").RequireRateLimiting(helloName);
+
+// Requests to this endpoint will be processed in 10 second intervals
+app.MapGet("/todoitems", async (TodoDb db) =>
+    await db.Todos.ToListAsync())
+    .RequireRateLimiting(todoName);
+
+// The limiter on this endpoint allows 1 request every 5 seconds
+app.MapGet("/todoitems/complete", async (TodoDb db) =>
+    await db.Todos.Where(t => t.IsComplete).ToListAsync())
+    .RequireRateLimiting(completeName);
+
+app.MapGet("/todoitems/{id}", async (int id, TodoDb db) =>
+    await db.Todos.FindAsync(id)
+        is Todo todo
+            ? Results.Ok(todo)
+            : Results.NotFound());
+
+app.MapPost("/todoitems", async (Todo todo, TodoDb db) =>
+{
+    db.Todos.Add(todo);
+    await db.SaveChangesAsync();
+
+    return Results.Created($"/todoitems/{todo.Id}", todo);
+});
+
+app.MapPut("/todoitems/{id}", async (int id, Todo inputTodo, TodoDb db) =>
+{
+    var todo = await db.Todos.FindAsync(id);
+
+    if (todo is null)
+    {
+        return Results.NotFound();
+    }
+
+    todo.Name = inputTodo.Name;
+    todo.IsComplete = inputTodo.IsComplete;
+
+    await db.SaveChangesAsync();
+
+    return Results.NoContent();
+});
+
+app.MapDelete("/todoitems/{id}", async (int id, TodoDb db) =>
+{
+    if (await db.Todos.FindAsync(id) is Todo todo)
+    {
+        db.Todos.Remove(todo);
+        await db.SaveChangesAsync();
+        return Results.Ok(todo);
+    }
+
+    return Results.NotFound();
+});
+
+app.Run();
+
+class Todo
+{
+    public int Id { get; set; }
+    public string? Name { get; set; }
+    public bool IsComplete { get; set; }
+}
+
+class TodoDb : DbContext
+{
+    public TodoDb(DbContextOptions<TodoDb> options)
+        : base(options) { }
+
+    public DbSet<Todo> Todos => Set<Todo>();
+}
diff --git a/src/Middleware/RateLimiting/samples/RateLimitingSample/Properties/launchSettings.json b/src/Middleware/RateLimiting/samples/RateLimitingSample/Properties/launchSettings.json
new file mode 100644
index 000000000000..b052590cfe49
--- /dev/null
+++ b/src/Middleware/RateLimiting/samples/RateLimitingSample/Properties/launchSettings.json
@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:8855",
+      "sslPort": 44312
+    }
+  },
+  "profiles": {
+    "RateLimitingSample": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7036;http://localhost:5085",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}
diff --git a/src/Middleware/RateLimiting/samples/RateLimitingSample/RateLimitingSample.csproj b/src/Middleware/RateLimiting/samples/RateLimitingSample/RateLimitingSample.csproj
new file mode 100644
index 000000000000..80fe67ee1e4b
--- /dev/null
+++ b/src/Middleware/RateLimiting/samples/RateLimitingSample/RateLimitingSample.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Reference Include="Microsoft.AspNetCore" />
+    <Reference Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" />
+    <Reference Include="Microsoft.AspNetCore.HttpsPolicy" />
+    <Reference Include="Microsoft.AspNetCore.Http.Results" />
+    <Reference Include="Microsoft.AspNetCore.Mvc" />
+    <Reference Include="Microsoft.AspNetCore.RateLimiting" />
+    <Reference Include="Microsoft.EntityFrameworkCore.InMemory" />
+    <Reference Include="Microsoft.Extensions.DependencyInjection" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/Middleware/RateLimiting/samples/RateLimitingSample/SampleRateLimiterPolicy.cs b/src/Middleware/RateLimiting/samples/RateLimitingSample/SampleRateLimiterPolicy.cs
new file mode 100644
index 000000000000..fc04c71a5202
--- /dev/null
+++ b/src/Middleware/RateLimiting/samples/RateLimitingSample/SampleRateLimiterPolicy.cs
@@ -0,0 +1,30 @@
+// 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.RateLimiting;
+using Microsoft.AspNetCore.RateLimiting;
+
+namespace RateLimitingSample;
+
+public class SampleRateLimiterPolicy : IRateLimiterPolicy<string>
+{
+    private Func<OnRejectedContext, CancellationToken, ValueTask>? _onRejected;
+
+    public SampleRateLimiterPolicy(ILogger<SampleRateLimiterPolicy> logger)
+    {
+        _onRejected = (context, token) =>
+        {
+            context.HttpContext.Response.StatusCode = 429;
+            logger.LogInformation($"Request rejected by {nameof(SampleRateLimiterPolicy)}");
+            return ValueTask.CompletedTask;
+        };
+    }
+
+    public Func<OnRejectedContext, CancellationToken, ValueTask>? OnRejected { get => _onRejected; }
+
+    // Use a sliding window limiter allowing 1 request every 10 seconds
+    public RateLimitPartition<string> GetPartition(HttpContext httpContext)
+    {
+        return RateLimitPartition.CreateSlidingWindowLimiter<string>(string.Empty, key => new SlidingWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 1, TimeSpan.FromSeconds(5), 1));
+    }
+}
diff --git a/src/Middleware/RateLimiting/samples/RateLimitingSample/appsettings.Development.json b/src/Middleware/RateLimiting/samples/RateLimitingSample/appsettings.Development.json
new file mode 100644
index 000000000000..0c208ae9181e
--- /dev/null
+++ b/src/Middleware/RateLimiting/samples/RateLimitingSample/appsettings.Development.json
@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}
diff --git a/src/Middleware/RateLimiting/samples/RateLimitingSample/appsettings.json b/src/Middleware/RateLimiting/samples/RateLimitingSample/appsettings.json
new file mode 100644
index 000000000000..10f68b8c8b4f
--- /dev/null
+++ b/src/Middleware/RateLimiting/samples/RateLimitingSample/appsettings.json
@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}
diff --git a/src/Middleware/RateLimiting/src/DefaultCombinedLease.cs b/src/Middleware/RateLimiting/src/DefaultCombinedLease.cs
new file mode 100644
index 000000000000..c7581155f18f
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/DefaultCombinedLease.cs
@@ -0,0 +1,99 @@
+// 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.RateLimiting;
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+internal sealed class DefaultCombinedLease : RateLimitLease
+{
+    private readonly RateLimitLease _globalLease;
+    private readonly RateLimitLease _endpointLease;
+    private HashSet<string>? _metadataNames;
+
+    public DefaultCombinedLease(RateLimitLease globalLease, RateLimitLease endpointLease)
+    {
+        _globalLease = globalLease;
+        _endpointLease = endpointLease;
+    }
+
+    public override bool IsAcquired => true;
+
+    public override IEnumerable<string> MetadataNames
+    {
+        get
+        {
+            if (_metadataNames is null)
+            {
+                _metadataNames = new HashSet<string>();
+                foreach (var metadataName in _globalLease.MetadataNames)
+                {
+                    _metadataNames.Add(metadataName);
+                }
+                foreach (var metadataName in _endpointLease.MetadataNames)
+                {
+                    _metadataNames.Add(metadataName);
+                }
+            }
+            return _metadataNames;
+        }
+    }
+
+    public override bool TryGetMetadata(string metadataName, out object? metadata)
+    {
+        // Use the first metadata item of a given name, ignore duplicates, we can't reliably merge arbitrary metadata
+        // Creating an object[] if there are multiple of the same metadataName could work, but makes consumption of metadata messy
+        // and makes MetadataName.Create<T>(...) uses no longer work
+        if (_endpointLease.TryGetMetadata(metadataName, out metadata))
+        {
+            return true;
+        }
+        if (_globalLease.TryGetMetadata(metadataName, out metadata))
+        {
+            return true;
+        }
+
+        metadata = null;
+        return false;
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        List<Exception>? exceptions = null;
+
+        // Dispose endpoint lease first, then global lease (reverse order of when they were acquired)
+        // Avoids issues where dispose might unblock a queued acquire and then the acquire fails when acquiring the next limiter.
+        // When disposing in reverse order there wont be any issues of unblocking an acquire that affects acquires on limiters in the chain after it
+        try
+        {
+            _endpointLease.Dispose();
+        }
+        catch (Exception ex)
+        {
+            exceptions ??= new List<Exception>();
+            exceptions.Add(ex);
+        }
+
+        try
+        {
+            _globalLease.Dispose();
+        }
+        catch (Exception ex)
+        {
+            exceptions ??= new List<Exception>(1);
+            exceptions.Add(ex);
+        }
+
+        if (exceptions is not null)
+        {
+            if (exceptions.Count == 1)
+            {
+                throw exceptions[0];
+            }
+            else
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+    }
+}
diff --git a/src/Middleware/RateLimiting/src/DefaultKeyType.cs b/src/Middleware/RateLimiting/src/DefaultKeyType.cs
new file mode 100644
index 000000000000..ea9b2b0d6c36
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/DefaultKeyType.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+internal struct DefaultKeyType
+{
+    public DefaultKeyType(string policyName, object? key, object? factory = null)
+    {
+        PolicyName = policyName;
+        Key = key;
+        Factory = factory;
+    }
+
+    public string PolicyName { get; }
+
+    public object? Key { get; }
+
+    // This is really a Func<TPartitionKey, RateLimiter>
+    public object? Factory { get; }
+}
diff --git a/src/Middleware/RateLimiting/src/DefaultKeyTypeEqualityComparer.cs b/src/Middleware/RateLimiting/src/DefaultKeyTypeEqualityComparer.cs
new file mode 100644
index 000000000000..08997d7136f0
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/DefaultKeyTypeEqualityComparer.cs
@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+internal sealed class DefaultKeyTypeEqualityComparer : IEqualityComparer<DefaultKeyType>
+{
+    public bool Equals(DefaultKeyType x, DefaultKeyType y)
+    {
+        var xKey = x.Key;
+        var yKey = y.Key;
+        if (xKey == null && yKey == null)
+        {
+            return string.Equals(x.PolicyName, y.PolicyName, StringComparison.Ordinal);
+        }
+        else if (xKey == null || yKey == null)
+        {
+            return false;
+        }
+
+        return string.Equals(x.PolicyName, y.PolicyName, StringComparison.Ordinal) && xKey.Equals(yKey);
+    }
+
+    public int GetHashCode([DisallowNull] DefaultKeyType obj)
+    {
+        return HashCode.Combine(obj.Key, obj.PolicyName);
+    }
+}
diff --git a/src/Middleware/RateLimiting/src/DefaultRateLimiterPolicy.cs b/src/Middleware/RateLimiting/src/DefaultRateLimiterPolicy.cs
new file mode 100644
index 000000000000..e155779381f9
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/DefaultRateLimiterPolicy.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.RateLimiting;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+internal sealed class DefaultRateLimiterPolicy : IRateLimiterPolicy<DefaultKeyType>
+{
+    private readonly Func<HttpContext, RateLimitPartition<DefaultKeyType>> _partitioner;
+    private readonly Func<OnRejectedContext, CancellationToken, ValueTask>? _onRejected;
+
+    public DefaultRateLimiterPolicy(Func<HttpContext, RateLimitPartition<DefaultKeyType>> partitioner, Func<OnRejectedContext, CancellationToken, ValueTask>? onRejected)
+    {
+        _partitioner = partitioner;
+        _onRejected = onRejected;
+    }
+
+    public Func<OnRejectedContext, CancellationToken, ValueTask>? OnRejected => _onRejected;
+
+    public RateLimitPartition<DefaultKeyType> GetPartition(HttpContext httpContext)
+    {
+        return _partitioner(httpContext);
+    }
+}
diff --git a/src/Middleware/RateLimiting/src/IRateLimiterMetadata.cs b/src/Middleware/RateLimiting/src/IRateLimiterMetadata.cs
new file mode 100644
index 000000000000..54b8306cd5a7
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/IRateLimiterMetadata.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+/// <summary>
+/// An interface which can be used to identify a type which provides metadata needed for enabling request rate limiting support.
+/// </summary>
+internal interface IRateLimiterMetadata
+{
+    /// <summary>
+    /// The name of the policy which needs to be applied.
+    /// </summary>
+    string PolicyName { get; }
+}
diff --git a/src/Middleware/RateLimiting/src/IRateLimiterPolicy.cs b/src/Middleware/RateLimiting/src/IRateLimiterPolicy.cs
new file mode 100644
index 000000000000..74872538580b
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/IRateLimiterPolicy.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.RateLimiting;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+/// <summary>
+/// An interface which is used to represent a RateLimiter policy.
+/// </summary>
+public interface IRateLimiterPolicy<TPartitionKey>
+{
+    /// <summary>
+    /// Gets the <see cref="Func{OnRejectedContext, CancellationToken, ValueTask}"/> that handles requests rejected by this middleware.
+    /// </summary>
+    Func<OnRejectedContext, CancellationToken, ValueTask>? OnRejected { get; }
+
+    /// <summary>
+    /// Gets the <see cref="RateLimitPartition{TPartitionKey}"/> that applies to the given <see cref="HttpContext"/>.
+    /// </summary>
+    /// <param name="httpContext">The <see cref="HttpContext"/> to get the partition for.</param>
+    RateLimitPartition<TPartitionKey> GetPartition(HttpContext httpContext);
+}
diff --git a/src/Middleware/RateLimiting/src/LeaseContext.cs b/src/Middleware/RateLimiting/src/LeaseContext.cs
new file mode 100644
index 000000000000..a264241f3a9d
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/LeaseContext.cs
@@ -0,0 +1,18 @@
+// 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.RateLimiting;
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+internal struct LeaseContext : IDisposable
+{
+    public bool? GlobalRejected { get; init; }
+
+    public required RateLimitLease Lease { get; init; }
+
+    public void Dispose()
+    {
+        Lease.Dispose();
+    }
+}
diff --git a/src/Middleware/RateLimiting/src/NoLimiter.cs b/src/Middleware/RateLimiting/src/NoLimiter.cs
deleted file mode 100644
index e663b1f16019..000000000000
--- a/src/Middleware/RateLimiting/src/NoLimiter.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-// 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.RateLimiting;
-
-namespace Microsoft.AspNetCore.RateLimiting;
-internal sealed class NoLimiter<TResource> : PartitionedRateLimiter<TResource>
-{
-    public override int GetAvailablePermits(TResource resourceID)
-    {
-        return 1;
-    }
-
-    protected override RateLimitLease AcquireCore(TResource resourceID, int permitCount)
-    {
-        return new NoLimiterLease();
-    }
-
-    protected override ValueTask<RateLimitLease> WaitAsyncCore(TResource resourceID, int permitCount, CancellationToken cancellationToken)
-    {
-        return new ValueTask<RateLimitLease>(new NoLimiterLease());
-    }
-}
-
-internal sealed class NoLimiterLease : RateLimitLease
-{
-    public override bool IsAcquired => true;
-
-    public override IEnumerable<string> MetadataNames => new List<string>();
-
-    public override bool TryGetMetadata(string metadataName, out object? metadata)
-    {
-        metadata = null;
-        return false;
-    }
-}
diff --git a/src/Middleware/RateLimiting/src/OnRejectedContext.cs b/src/Middleware/RateLimiting/src/OnRejectedContext.cs
new file mode 100644
index 000000000000..05709555681d
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/OnRejectedContext.cs
@@ -0,0 +1,23 @@
+// 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.RateLimiting;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+/// <summary>
+/// Holds state needed for the OnRejected callback in the RateLimitingMiddleware.
+/// </summary>
+public sealed class OnRejectedContext
+{
+    /// <summary>
+    /// Gets or sets the <see cref="HttpContext"/> that the OnRejected callback will have access to
+    /// </summary>
+    public required HttpContext HttpContext { get; init; }
+
+    /// <summary>
+    /// Gets or sets the failed <see cref="RateLimitLease"/> that the OnRejected callback will have access to
+    /// </summary>
+    public required RateLimitLease Lease { get; init; }
+}
diff --git a/src/Middleware/RateLimiting/src/PolicyNameKey.cs b/src/Middleware/RateLimiting/src/PolicyNameKey.cs
new file mode 100644
index 000000000000..d473aad38fc8
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/PolicyNameKey.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+internal sealed class PolicyNameKey
+{
+    public required string PolicyName { get; init; }
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is PolicyNameKey key)
+        {
+            return PolicyName == key.PolicyName;
+        }
+        return false;
+    }
+
+    public override int GetHashCode()
+    {
+        return PolicyName.GetHashCode();
+    }
+}
diff --git a/src/Middleware/RateLimiting/src/PublicAPI.Unshipped.txt b/src/Middleware/RateLimiting/src/PublicAPI.Unshipped.txt
index b62cec89b1cc..3bbcc5cb4c20 100644
--- a/src/Middleware/RateLimiting/src/PublicAPI.Unshipped.txt
+++ b/src/Middleware/RateLimiting/src/PublicAPI.Unshipped.txt
@@ -1,11 +1,31 @@
+Microsoft.AspNetCore.Builder.RateLimiterApplicationBuilderExtensions
+Microsoft.AspNetCore.Builder.RateLimiterEndpointConventionBuilderExtensions
+Microsoft.AspNetCore.RateLimiting.IRateLimiterPolicy<TPartitionKey>
+Microsoft.AspNetCore.RateLimiting.IRateLimiterPolicy<TPartitionKey>.GetPartition(Microsoft.AspNetCore.Http.HttpContext! httpContext) -> System.Threading.RateLimiting.RateLimitPartition<TPartitionKey>
+Microsoft.AspNetCore.RateLimiting.IRateLimiterPolicy<TPartitionKey>.OnRejected.get -> System.Func<Microsoft.AspNetCore.RateLimiting.OnRejectedContext!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>?
+Microsoft.AspNetCore.RateLimiting.OnRejectedContext
+Microsoft.AspNetCore.RateLimiting.OnRejectedContext.HttpContext.get -> Microsoft.AspNetCore.Http.HttpContext!
+Microsoft.AspNetCore.RateLimiting.OnRejectedContext.HttpContext.init -> void
+Microsoft.AspNetCore.RateLimiting.OnRejectedContext.Lease.get -> System.Threading.RateLimiting.RateLimitLease!
+Microsoft.AspNetCore.RateLimiting.OnRejectedContext.Lease.init -> void
+Microsoft.AspNetCore.RateLimiting.OnRejectedContext.OnRejectedContext() -> void
 Microsoft.AspNetCore.RateLimiting.RateLimiterOptions
-Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.DefaultRejectionStatusCode.get -> int
-Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.DefaultRejectionStatusCode.set -> void
-Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.Limiter.get -> System.Threading.RateLimiting.PartitionedRateLimiter<Microsoft.AspNetCore.Http.HttpContext!>!
-Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.Limiter.set -> void
-Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.OnRejected.get -> System.Func<Microsoft.AspNetCore.Http.HttpContext!, System.Threading.RateLimiting.RateLimitLease!, System.Threading.Tasks.Task!>!
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.AddPolicy<TPartitionKey, TPolicy>(string! policyName) -> Microsoft.AspNetCore.RateLimiting.RateLimiterOptions!
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.AddPolicy<TPartitionKey>(string! policyName, Microsoft.AspNetCore.RateLimiting.IRateLimiterPolicy<TPartitionKey>! policy) -> Microsoft.AspNetCore.RateLimiting.RateLimiterOptions!
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.AddPolicy<TPartitionKey>(string! policyName, System.Func<Microsoft.AspNetCore.Http.HttpContext!, System.Threading.RateLimiting.RateLimitPartition<TPartitionKey>>! partitioner) -> Microsoft.AspNetCore.RateLimiting.RateLimiterOptions!
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.GlobalLimiter.get -> System.Threading.RateLimiting.PartitionedRateLimiter<Microsoft.AspNetCore.Http.HttpContext!>?
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.GlobalLimiter.set -> void
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.OnRejected.get -> System.Func<Microsoft.AspNetCore.RateLimiting.OnRejectedContext!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>?
 Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.OnRejected.set -> void
 Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.RateLimiterOptions() -> void
-Microsoft.AspNetCore.RateLimiting.RateLimitingApplicationBuilderExtensions
-static Microsoft.AspNetCore.RateLimiting.RateLimitingApplicationBuilderExtensions.UseRateLimiter(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
-static Microsoft.AspNetCore.RateLimiting.RateLimitingApplicationBuilderExtensions.UseRateLimiter(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app, Microsoft.AspNetCore.RateLimiting.RateLimiterOptions! options) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.RejectionStatusCode.get -> int
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptions.RejectionStatusCode.set -> void
+Microsoft.AspNetCore.RateLimiting.RateLimiterOptionsExtensions
+static Microsoft.AspNetCore.Builder.RateLimiterApplicationBuilderExtensions.UseRateLimiter(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
+static Microsoft.AspNetCore.Builder.RateLimiterApplicationBuilderExtensions.UseRateLimiter(this Microsoft.AspNetCore.Builder.IApplicationBuilder! app, Microsoft.AspNetCore.RateLimiting.RateLimiterOptions! options) -> Microsoft.AspNetCore.Builder.IApplicationBuilder!
+static Microsoft.AspNetCore.Builder.RateLimiterEndpointConventionBuilderExtensions.RequireRateLimiting<TBuilder>(this TBuilder builder, string! policyName) -> TBuilder
+static Microsoft.AspNetCore.RateLimiting.RateLimiterOptionsExtensions.AddConcurrencyLimiter(this Microsoft.AspNetCore.RateLimiting.RateLimiterOptions! options, string! policyName, System.Threading.RateLimiting.ConcurrencyLimiterOptions! concurrencyLimiterOptions) -> Microsoft.AspNetCore.RateLimiting.RateLimiterOptions!
+static Microsoft.AspNetCore.RateLimiting.RateLimiterOptionsExtensions.AddFixedWindowLimiter(this Microsoft.AspNetCore.RateLimiting.RateLimiterOptions! options, string! policyName, System.Threading.RateLimiting.FixedWindowRateLimiterOptions! fixedWindowRateLimiterOptions) -> Microsoft.AspNetCore.RateLimiting.RateLimiterOptions!
+static Microsoft.AspNetCore.RateLimiting.RateLimiterOptionsExtensions.AddNoLimiter(this Microsoft.AspNetCore.RateLimiting.RateLimiterOptions! options, string! policyName) -> Microsoft.AspNetCore.RateLimiting.RateLimiterOptions!
+static Microsoft.AspNetCore.RateLimiting.RateLimiterOptionsExtensions.AddSlidingWindowLimiter(this Microsoft.AspNetCore.RateLimiting.RateLimiterOptions! options, string! policyName, System.Threading.RateLimiting.SlidingWindowRateLimiterOptions! slidingWindowRateLimiterOptions) -> Microsoft.AspNetCore.RateLimiting.RateLimiterOptions!
+static Microsoft.AspNetCore.RateLimiting.RateLimiterOptionsExtensions.AddTokenBucketLimiter(this Microsoft.AspNetCore.RateLimiting.RateLimiterOptions! options, string! policyName, System.Threading.RateLimiting.TokenBucketRateLimiterOptions! tokenBucketRateLimiterOptions) -> Microsoft.AspNetCore.RateLimiting.RateLimiterOptions!
diff --git a/src/Middleware/RateLimiting/src/RateLimitingApplicationBuilderExtensions.cs b/src/Middleware/RateLimiting/src/RateLimiterApplicationBuilderExtensions.cs
similarity index 88%
rename from src/Middleware/RateLimiting/src/RateLimitingApplicationBuilderExtensions.cs
rename to src/Middleware/RateLimiting/src/RateLimiterApplicationBuilderExtensions.cs
index 64dddf417d04..cd1ec7b82604 100644
--- a/src/Middleware/RateLimiting/src/RateLimitingApplicationBuilderExtensions.cs
+++ b/src/Middleware/RateLimiting/src/RateLimiterApplicationBuilderExtensions.cs
@@ -1,15 +1,15 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.RateLimiting;
 using Microsoft.Extensions.Options;
 
-namespace Microsoft.AspNetCore.RateLimiting;
+namespace Microsoft.AspNetCore.Builder;
 
 /// <summary>
 /// Extension methods for the RateLimiting middleware.
 /// </summary>
-public static class RateLimitingApplicationBuilderExtensions
+public static class RateLimiterApplicationBuilderExtensions
 {
     /// <summary>
     /// Enables rate limiting for the application.
diff --git a/src/Middleware/RateLimiting/src/RateLimiterEndpointConventionBuilderExtensions.cs b/src/Middleware/RateLimiting/src/RateLimiterEndpointConventionBuilderExtensions.cs
new file mode 100644
index 000000000000..333499a7dea3
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/RateLimiterEndpointConventionBuilderExtensions.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.RateLimiting;
+
+namespace Microsoft.AspNetCore.Builder;
+
+/// <summary>
+/// Rate limiter extension methods for <see cref="IEndpointConventionBuilder"/>.
+/// </summary>
+public static class RateLimiterEndpointConventionBuilderExtensions
+{
+    /// <summary>
+    /// Adds the specified rate limiting policy to the endpoint(s).
+    /// </summary>
+    /// <param name="builder">The endpoint convention builder.</param>
+    /// <param name="policyName">The name of the rate limiting policy to add to the endpoint.</param>
+    /// <returns>The original convention builder parameter.</returns>
+    public static TBuilder RequireRateLimiting<TBuilder>(this TBuilder builder, string policyName) where TBuilder : IEndpointConventionBuilder
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+
+        ArgumentNullException.ThrowIfNull(policyName);
+
+        builder.Add(endpointBuilder =>
+        {
+            endpointBuilder.Metadata.Add(new RateLimiterMetadata(policyName));
+        });
+
+        return builder;
+    }
+}
diff --git a/src/Middleware/RateLimiting/src/RateLimiterMetadata.cs b/src/Middleware/RateLimiting/src/RateLimiterMetadata.cs
new file mode 100644
index 000000000000..08498eb77199
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/RateLimiterMetadata.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.
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+/// <summary>
+/// Metadata that provides endpoint-specific request rate limiting.
+/// </summary>
+internal sealed class RateLimiterMetadata : IRateLimiterMetadata
+{
+    /// <summary>
+    /// Creates a new instance of <see cref="RateLimiterMetadata"/> using the specified policy.
+    /// </summary>
+    /// <param name="policyName">The name of the policy which needs to be applied.</param>
+    public RateLimiterMetadata(string policyName)
+    {
+        PolicyName = policyName;
+    }
+
+    /// <summary>
+    /// The name of the policy which needs to be applied.
+    /// </summary>
+    public string PolicyName { get; }
+}
diff --git a/src/Middleware/RateLimiting/src/RateLimiterOptions.cs b/src/Middleware/RateLimiting/src/RateLimiterOptions.cs
index bc1ab30b7a37..7652613506ed 100644
--- a/src/Middleware/RateLimiting/src/RateLimiterOptions.cs
+++ b/src/Middleware/RateLimiting/src/RateLimiterOptions.cs
@@ -1,8 +1,10 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Threading.RateLimiting;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.AspNetCore.RateLimiting;
 
@@ -11,30 +13,22 @@ namespace Microsoft.AspNetCore.RateLimiting;
 /// </summary>
 public sealed class RateLimiterOptions
 {
-    // TODO - Provide a default?
-    private PartitionedRateLimiter<HttpContext> _limiter = new NoLimiter<HttpContext>();
-    private Func<HttpContext, RateLimitLease, Task> _onRejected = (context, lease) =>
-    {
-        return Task.CompletedTask;
-    };
+    internal Dictionary<string, DefaultRateLimiterPolicy> PolicyMap { get; }
+        = new Dictionary<string, DefaultRateLimiterPolicy>(StringComparer.Ordinal);
+
+    internal Dictionary<string, Func<IServiceProvider, DefaultRateLimiterPolicy>> UnactivatedPolicyMap { get; }
+        = new Dictionary<string, Func<IServiceProvider, DefaultRateLimiterPolicy>>(StringComparer.Ordinal);
 
     /// <summary>
-    /// Gets or sets the <see cref="PartitionedRateLimiter{TResource}"/>
+    /// Gets or sets the global <see cref="PartitionedRateLimiter{HttpContext}"/> that will be applied on all requests.
+    /// The global limiter will be executed first, followed by the endpoint-specific limiter, if one exists.
     /// </summary>
-    public PartitionedRateLimiter<HttpContext> Limiter
-    {
-        get => _limiter;
-        set => _limiter = value ?? throw new ArgumentNullException(nameof(value));
-    }
+    public PartitionedRateLimiter<HttpContext>? GlobalLimiter { get; set; }
 
     /// <summary>
-    /// Gets or sets a <see cref="Func{HttpContext, RateLimitLease, Task}"/> that handles requests rejected by this middleware.
+    /// Gets or sets a <see cref="Func{OnRejectedContext, CancellationToken, ValueTask}"/> that handles requests rejected by this middleware.
     /// </summary>
-    public Func<HttpContext, RateLimitLease, Task> OnRejected
-    {
-        get => _onRejected;
-        set => _onRejected = value ?? throw new ArgumentNullException(nameof(value));
-    }
+    public Func<OnRejectedContext, CancellationToken, ValueTask>? OnRejected { get; set; }
 
     /// <summary>
     /// Gets or sets the default status code to set on the response when a request is rejected.
@@ -44,5 +38,94 @@ public Func<HttpContext, RateLimitLease, Task> OnRejected
     /// This status code will be set before <see cref="OnRejected"/> is called, so any status code set by
     /// <see cref="OnRejected"/> will "win" over this default.
     /// </remarks>
-    public int DefaultRejectionStatusCode { get; set; } = StatusCodes.Status503ServiceUnavailable;
+    public int RejectionStatusCode { get; set; } = StatusCodes.Status503ServiceUnavailable;
+
+    /// <summary>
+    /// Adds a new rate limiting policy with the given <paramref name="policyName"/>
+    /// </summary>
+    /// <param name="policyName">The name to be associated with the given <see cref="RateLimiter"/>.</param>
+    /// <param name="partitioner">Method called every time an Acquire or WaitAsync call is made to determine what rate limiter to apply to the request.</param>
+    public RateLimiterOptions AddPolicy<TPartitionKey>(string policyName, Func<HttpContext, RateLimitPartition<TPartitionKey>> partitioner)
+    {
+        ArgumentNullException.ThrowIfNull(policyName);
+        ArgumentNullException.ThrowIfNull(partitioner);
+
+        if (PolicyMap.ContainsKey(policyName) || UnactivatedPolicyMap.ContainsKey(policyName))
+        {
+            throw new ArgumentException($"There already exists a policy with the name {policyName}.", nameof(policyName));
+        }
+
+        PolicyMap.Add(policyName, new DefaultRateLimiterPolicy(ConvertPartitioner<TPartitionKey>(policyName, partitioner), null));
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds a new rate limiting policy with the given policyName.
+    /// </summary>
+    /// <param name="policyName">The name to be associated with the given TPolicy.</param>
+    public RateLimiterOptions AddPolicy<TPartitionKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TPolicy>(string policyName) where TPolicy : IRateLimiterPolicy<TPartitionKey>
+    {
+        ArgumentNullException.ThrowIfNull(policyName);
+
+        if (PolicyMap.ContainsKey(policyName) || UnactivatedPolicyMap.ContainsKey(policyName))
+        {
+            throw new ArgumentException($"There already exists a policy with the name {policyName}.", nameof(policyName));
+        }
+
+        var policyType = new PolicyTypeState(typeof(TPolicy));
+        Func<IServiceProvider, DefaultRateLimiterPolicy> policyFunc = serviceProvider =>
+        {
+            var instance = (IRateLimiterPolicy<TPartitionKey>)ActivatorUtilities.CreateInstance(serviceProvider, policyType.PolicyType);
+            return new DefaultRateLimiterPolicy(ConvertPartitioner<TPartitionKey>(policyName, instance.GetPartition), instance.OnRejected);
+        };
+
+        UnactivatedPolicyMap.Add(policyName, policyFunc);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds a new rate limiting policy with the given policyName.
+    /// </summary>
+    /// <param name="policyName">The name to be associated with the given <see cref="IRateLimiterPolicy{TPartitionKey}"/>.</param>
+    /// <param name="policy">The <see cref="IRateLimiterPolicy{TPartitionKey}"/> to be applied.</param>
+    public RateLimiterOptions AddPolicy<TPartitionKey>(string policyName, IRateLimiterPolicy<TPartitionKey> policy)
+    {
+        ArgumentNullException.ThrowIfNull(policyName);
+
+        if (PolicyMap.ContainsKey(policyName) || UnactivatedPolicyMap.ContainsKey(policyName))
+        {
+            throw new ArgumentException($"There already exists a policy with the name {policyName}.", nameof(policyName));
+        }
+
+        ArgumentNullException.ThrowIfNull(policy);
+
+        PolicyMap.Add(policyName, new DefaultRateLimiterPolicy(ConvertPartitioner<TPartitionKey>(policyName, policy.GetPartition), policy.OnRejected));
+
+        return this;
+    }
+
+    // Converts a Partition<TKey> to a Partition<DefaultKeyType<TKey>> to prevent accidental collisions with the keys we create in the the RateLimiterOptionsExtensions.
+    private static Func<HttpContext, RateLimitPartition<DefaultKeyType>> ConvertPartitioner<TPartitionKey>(string policyName, Func<HttpContext, RateLimitPartition<TPartitionKey>> partitioner)
+    {
+        return context =>
+        {
+            RateLimitPartition<TPartitionKey> partition = partitioner(context);
+            var partitionKey = new DefaultKeyType(policyName, partition.PartitionKey, partition.Factory);
+            return new RateLimitPartition<DefaultKeyType>(partitionKey, static key => ((Func<TPartitionKey, RateLimiter>)key.Factory!)((TPartitionKey)key.Key!));
+        };
+    }
+
+    // Workaround for linker bug: https://github.com/dotnet/linker/issues/1981
+    private readonly struct PolicyTypeState
+    {
+        public PolicyTypeState([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type policyType)
+        {
+            PolicyType = policyType;
+        }
+
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
+        public Type PolicyType { get; }
+    }
 }
diff --git a/src/Middleware/RateLimiting/src/RateLimiterOptionsExtensions.cs b/src/Middleware/RateLimiting/src/RateLimiterOptionsExtensions.cs
new file mode 100644
index 000000000000..e7067ef5da5c
--- /dev/null
+++ b/src/Middleware/RateLimiting/src/RateLimiterOptionsExtensions.cs
@@ -0,0 +1,95 @@
+// 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.RateLimiting;
+
+namespace Microsoft.AspNetCore.RateLimiting;
+
+/// <summary>
+/// Extension methods for the RateLimiting middleware options.
+/// </summary>
+public static class RateLimiterOptionsExtensions
+{
+    /// <summary>
+    /// Adds a new <see cref="TokenBucketRateLimiter"/> with the given <see cref="TokenBucketRateLimiterOptions"/> to the <see cref="RateLimiterOptions"/>.
+    /// </summary>
+    /// <param name="options">The <see cref="RateLimiterOptions"/> to add a limiter to.</param>
+    /// <param name="policyName">The name that will be associated with the limiter.</param>
+    /// <param name="tokenBucketRateLimiterOptions">The <see cref="TokenBucketRateLimiterOptions"/> to be used for the limiter.</param>
+    /// <returns>This <see cref="RateLimiterOptions"/>.</returns>
+    public static RateLimiterOptions AddTokenBucketLimiter(this RateLimiterOptions options, string policyName, TokenBucketRateLimiterOptions tokenBucketRateLimiterOptions)
+    {
+        var key = new PolicyNameKey() { PolicyName = policyName };
+        return options.AddPolicy(policyName, context =>
+        {
+            return RateLimitPartition.CreateTokenBucketLimiter(key,
+                _ => tokenBucketRateLimiterOptions);
+        });
+    }
+
+    /// <summary>
+    /// Adds a new <see cref="FixedWindowRateLimiter"/> with the given <see cref="FixedWindowRateLimiterOptions"/> to the <see cref="RateLimiterOptions"/>.
+    /// </summary>
+    /// <param name="options">The <see cref="RateLimiterOptions"/> to add a limiter to.</param>
+    /// <param name="policyName">The name that will be associated with the limiter.</param>
+    /// <param name="fixedWindowRateLimiterOptions">The <see cref="FixedWindowRateLimiterOptions"/> to be used for the limiter.</param>
+    /// <returns>This <see cref="RateLimiterOptions"/>.</returns>
+    public static RateLimiterOptions AddFixedWindowLimiter(this RateLimiterOptions options, string policyName, FixedWindowRateLimiterOptions fixedWindowRateLimiterOptions)
+    {
+        var key = new PolicyNameKey() { PolicyName = policyName };
+        return options.AddPolicy(policyName, context =>
+        {
+            return RateLimitPartition.CreateFixedWindowLimiter(key,
+                _ => fixedWindowRateLimiterOptions);
+        });
+    }
+
+    /// <summary>
+    /// Adds a new <see cref="SlidingWindowRateLimiter"/> with the given <see cref="SlidingWindowRateLimiterOptions"/> to the <see cref="RateLimiterOptions"/>.
+    /// </summary>
+    /// <param name="options">The <see cref="RateLimiterOptions"/> to add a limiter to.</param>
+    /// <param name="policyName">The name that will be associated with the limiter.</param>
+    /// <param name="slidingWindowRateLimiterOptions">The <see cref="SlidingWindowRateLimiterOptions"/> to be used for the limiter.</param>
+    /// <returns>This <see cref="RateLimiterOptions"/>.</returns>
+    public static RateLimiterOptions AddSlidingWindowLimiter(this RateLimiterOptions options, string policyName, SlidingWindowRateLimiterOptions slidingWindowRateLimiterOptions)
+    {
+        var key = new PolicyNameKey() { PolicyName = policyName };
+        return options.AddPolicy(policyName, context =>
+        {
+            return RateLimitPartition.CreateSlidingWindowLimiter(key,
+                _ => slidingWindowRateLimiterOptions);
+        });
+    }
+
+    /// <summary>
+    /// Adds a new <see cref="ConcurrencyLimiter"/> with the given <see cref="ConcurrencyLimiterOptions"/> to the <see cref="RateLimiterOptions"/>.
+    /// </summary>
+    /// <param name="options">The <see cref="RateLimiterOptions"/> to add a limiter to.</param>
+    /// <param name="policyName">The name that will be associated with the limiter.</param>
+    /// <param name="concurrencyLimiterOptions">The <see cref="ConcurrencyLimiterOptions"/> to be used for the limiter.</param>
+    /// <returns>This <see cref="RateLimiterOptions"/>.</returns>
+    public static RateLimiterOptions AddConcurrencyLimiter(this RateLimiterOptions options, string policyName, ConcurrencyLimiterOptions concurrencyLimiterOptions)
+    {
+        var key = new PolicyNameKey() { PolicyName = policyName };
+        return options.AddPolicy(policyName, context =>
+        {
+            return RateLimitPartition.CreateConcurrencyLimiter(key,
+                _ => concurrencyLimiterOptions);
+        });
+    }
+
+    /// <summary>
+    /// Adds a new no-op <see cref="RateLimiter"/> to the <see cref="RateLimiterOptions"/>.
+    /// </summary>
+    /// <param name="options">The <see cref="RateLimiterOptions"/> to add a limiter to.</param>
+    /// <param name="policyName">The name that will be associated with the limiter.</param>
+    /// <returns>This <see cref="RateLimiterOptions"/>.</returns>
+    public static RateLimiterOptions AddNoLimiter(this RateLimiterOptions options, string policyName)
+    {
+        var key = new PolicyNameKey() { PolicyName = policyName };
+        return options.AddPolicy(policyName, context =>
+        {
+            return RateLimitPartition.CreateNoLimiter(key);
+        });
+    }
+}
diff --git a/src/Middleware/RateLimiting/src/RateLimitingMiddleware.cs b/src/Middleware/RateLimiting/src/RateLimitingMiddleware.cs
index a97aa7c9ee83..d352e3546dde 100644
--- a/src/Middleware/RateLimiting/src/RateLimitingMiddleware.cs
+++ b/src/Middleware/RateLimiting/src/RateLimitingMiddleware.cs
@@ -14,10 +14,13 @@ namespace Microsoft.AspNetCore.RateLimiting;
 internal sealed partial class RateLimitingMiddleware
 {
     private readonly RequestDelegate _next;
-    private readonly Func<HttpContext, RateLimitLease, Task> _onRejected;
+    private readonly Func<OnRejectedContext, CancellationToken, ValueTask>? _defaultOnRejected;
     private readonly ILogger _logger;
-    private readonly PartitionedRateLimiter<HttpContext> _limiter;
+    private readonly PartitionedRateLimiter<HttpContext>? _globalLimiter;
+    private readonly PartitionedRateLimiter<HttpContext> _endpointLimiter;
     private readonly int _rejectionStatusCode;
+    private readonly Dictionary<string, DefaultRateLimiterPolicy> _policyMap;
+    private readonly DefaultKeyType _defaultPolicyKey = new DefaultKeyType("__defaultPolicy", new PolicyNameKey { PolicyName = "__defaultPolicyKey" });
 
     /// <summary>
     /// Creates a new <see cref="RateLimitingMiddleware"/>.
@@ -25,15 +28,28 @@ internal sealed partial class RateLimitingMiddleware
     /// <param name="next">The <see cref="RequestDelegate"/> representing the next middleware in the pipeline.</param>
     /// <param name="logger">The <see cref="ILogger"/> used for logging.</param>
     /// <param name="options">The options for the middleware.</param>
-    public RateLimitingMiddleware(RequestDelegate next, ILogger<RateLimitingMiddleware> logger, IOptions<RateLimiterOptions> options)
+    /// <param name="serviceProvider">The service provider.</param>
+    public RateLimitingMiddleware(RequestDelegate next, ILogger<RateLimitingMiddleware> logger, IOptions<RateLimiterOptions> options, IServiceProvider serviceProvider)
     {
-        _next = next ?? throw new ArgumentNullException(nameof(next));
+        ArgumentNullException.ThrowIfNull(next);
+        ArgumentNullException.ThrowIfNull(logger);
+        ArgumentNullException.ThrowIfNull(serviceProvider);
 
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        _next = next;
+        _logger = logger;
+        _defaultOnRejected = options.Value.OnRejected;
+        _rejectionStatusCode = options.Value.RejectionStatusCode;
+        _policyMap = new Dictionary<string, DefaultRateLimiterPolicy>(options.Value.PolicyMap);
+
+        // Activate policies passed to AddPolicy<TPartitionKey, TPolicy>
+        foreach (var unactivatedPolicy in options.Value.UnactivatedPolicyMap)
+        {
+            _policyMap.Add(unactivatedPolicy.Key, unactivatedPolicy.Value(serviceProvider));
+        }
+
+        _globalLimiter = options.Value.GlobalLimiter;
+        _endpointLimiter = CreateEndpointLimiter();
 
-        _limiter = options.Value.Limiter;
-        _onRejected = options.Value.OnRejected;
-        _rejectionStatusCode = options.Value.DefaultRejectionStatusCode;
     }
 
     // TODO - EventSource?
@@ -44,35 +60,139 @@ public RateLimitingMiddleware(RequestDelegate next, ILogger<RateLimitingMiddlewa
     /// <returns>A <see cref="Task"/> that completes when the request leaves.</returns>
     public async Task Invoke(HttpContext context)
     {
-        using var lease = await TryAcquireAsync(context);
-        if (lease.IsAcquired)
+        using var leaseContext = await TryAcquireAsync(context);
+        if (leaseContext.Lease.IsAcquired)
         {
             await _next(context);
         }
         else
         {
+            var thisRequestOnRejected = _defaultOnRejected;
             RateLimiterLog.RequestRejectedLimitsExceeded(_logger);
             // OnRejected "wins" over DefaultRejectionStatusCode - we set DefaultRejectionStatusCode first,
             // then call OnRejected in case it wants to do any further modification of the status code.
             context.Response.StatusCode = _rejectionStatusCode;
-            await _onRejected(context, lease);
+
+            // If this request was rejected by the endpoint limiter, use its OnRejected if available.
+            if (leaseContext.GlobalRejected == false)
+            {
+                DefaultRateLimiterPolicy? policy;
+                var policyName = context.GetEndpoint()?.Metadata.GetMetadata<IRateLimiterMetadata>()?.PolicyName;
+                // Use custom policy OnRejected if available, else use OnRejected from the Options if available.
+                if (policyName is not null && _policyMap.TryGetValue(policyName, out policy) && policy.OnRejected is not null)
+                {
+                    thisRequestOnRejected = policy.OnRejected;
+                }
+            }
+            if (thisRequestOnRejected is not null)
+            {
+                await thisRequestOnRejected(new OnRejectedContext() { HttpContext = context, Lease = leaseContext.Lease }, context.RequestAborted);
+            }
         }
     }
 
-    private ValueTask<RateLimitLease> TryAcquireAsync(HttpContext context)
+    private ValueTask<LeaseContext> TryAcquireAsync(HttpContext context)
     {
-        var lease = _limiter.Acquire(context);
-        if (lease.IsAcquired)
+        var leaseContext = CombinedAcquire(context);
+        if (leaseContext.Lease.IsAcquired)
         {
-            return ValueTask.FromResult(lease);
+            return ValueTask.FromResult(leaseContext);
         }
 
-        return _limiter.WaitAsync(context, cancellationToken: context.RequestAborted);
+        return CombinedWaitAsync(context, context.RequestAborted);
+    }
+
+    private LeaseContext CombinedAcquire(HttpContext context)
+    {
+        RateLimitLease? globalLease = null;
+        RateLimitLease? endpointLease = null;
+
+        try
+        {
+            if (_globalLimiter is not null)
+            {
+                globalLease = _globalLimiter.Acquire(context);
+                if (!globalLease.IsAcquired)
+                {
+                    return new LeaseContext() { GlobalRejected = true, Lease = globalLease };
+                }
+            }
+            endpointLease = _endpointLimiter.Acquire(context);
+            if (!endpointLease.IsAcquired)
+            {
+                globalLease?.Dispose();
+                return new LeaseContext() { GlobalRejected = false, Lease = endpointLease };
+            }
+        }
+        catch (Exception)
+        {
+            endpointLease?.Dispose();
+            globalLease?.Dispose();
+            throw;
+        }
+        return globalLease is null ? new LeaseContext() { Lease = endpointLease } : new LeaseContext() { Lease = new DefaultCombinedLease(globalLease, endpointLease) };
+    }
+
+    private async ValueTask<LeaseContext> CombinedWaitAsync(HttpContext context, CancellationToken cancellationToken)
+    {
+        RateLimitLease? globalLease = null;
+        RateLimitLease? endpointLease = null;
+
+        try
+        {
+            if (_globalLimiter is not null)
+            {
+                globalLease = await _globalLimiter.WaitAsync(context, cancellationToken: cancellationToken);
+                if (!globalLease.IsAcquired)
+                {
+                    return new LeaseContext() { GlobalRejected = true, Lease = globalLease };
+                }
+            }
+            endpointLease = await _endpointLimiter.WaitAsync(context, cancellationToken: cancellationToken);
+            if (!endpointLease.IsAcquired)
+            {
+                globalLease?.Dispose();
+                return new LeaseContext() { GlobalRejected = false, Lease = endpointLease };
+            }
+        }
+        catch (Exception)
+        {
+            endpointLease?.Dispose();
+            globalLease?.Dispose();
+            throw;
+        }
+
+        return globalLease is null ? new LeaseContext() { Lease = endpointLease } : new LeaseContext() { Lease = new DefaultCombinedLease(globalLease, endpointLease) };
+    }
+
+    // Create the endpoint-specific PartitionedRateLimiter
+    private PartitionedRateLimiter<HttpContext> CreateEndpointLimiter()
+    {
+        // If we have a policy for this endpoint, use its partitioner. Else use a NoLimiter.
+        return PartitionedRateLimiter.Create<HttpContext, DefaultKeyType>(context =>
+        {
+            var name = context.GetEndpoint()?.Metadata.GetMetadata<IRateLimiterMetadata>()?.PolicyName;
+            if (name is not null)
+            {
+                if (_policyMap.TryGetValue(name, out var policy))
+                {
+                    return policy.GetPartition(context);
+                }
+                else
+                {
+                    throw new InvalidOperationException($"This endpoint requires a rate limiting policy with name {name}, but no such policy exists.");
+                }
+            }
+            return RateLimitPartition.CreateNoLimiter<DefaultKeyType>(_defaultPolicyKey);
+        }, new DefaultKeyTypeEqualityComparer());
     }
 
     private static partial class RateLimiterLog
     {
         [LoggerMessage(1, LogLevel.Debug, "Rate limits exceeded, rejecting this request.", EventName = "RequestRejectedLimitsExceeded")]
         internal static partial void RequestRejectedLimitsExceeded(ILogger logger);
+
+        [LoggerMessage(2, LogLevel.Debug, "This endpoint requires a rate limiting policy with name {PolicyName}, but no such policy exists.", EventName = "WarnMissingPolicy")]
+        internal static partial void WarnMissingPolicy(ILogger logger, string policyName);
     }
 }
diff --git a/src/Middleware/RateLimiting/test/RateLimitingApplicationBuilderExtensionsTests.cs b/src/Middleware/RateLimiting/test/RateLimitingApplicationBuilderExtensionsTests.cs
index 37d6d5bc4c37..45afd2182a4d 100644
--- a/src/Middleware/RateLimiting/test/RateLimitingApplicationBuilderExtensionsTests.cs
+++ b/src/Middleware/RateLimiting/test/RateLimitingApplicationBuilderExtensionsTests.cs
@@ -14,7 +14,7 @@ public class RateLimitingApplicationBuilderExtensionsTests : LoggedTest
     [Fact]
     public void UseRateLimiter_ThrowsOnNullAppBuilder()
     {
-        Assert.Throws<ArgumentNullException>(() => RateLimitingApplicationBuilderExtensions.UseRateLimiter(null));
+        Assert.Throws<ArgumentNullException>(() => RateLimiterApplicationBuilderExtensions.UseRateLimiter(null));
     }
 
     [Fact]
@@ -29,15 +29,15 @@ public void UseRateLimiter_RespectsOptions()
     {
         // These are the options that should get used
         var options = new RateLimiterOptions();
-        options.DefaultRejectionStatusCode = 429;
-        options.Limiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
+        options.RejectionStatusCode = 429;
+        options.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
 
         // These should not get used
         var services = new ServiceCollection();
         services.Configure<RateLimiterOptions>(options =>
         {
-            options.Limiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
-            options.DefaultRejectionStatusCode = 404;
+            options.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
+            options.RejectionStatusCode = 404;
         });
         services.AddLogging();
         var serviceProvider = services.BuildServiceProvider();
diff --git a/src/Middleware/RateLimiting/test/RateLimitingMiddlewareTests.cs b/src/Middleware/RateLimiting/test/RateLimitingMiddlewareTests.cs
index 903b225ed41b..91b0697c5f4a 100644
--- a/src/Middleware/RateLimiting/test/RateLimitingMiddlewareTests.cs
+++ b/src/Middleware/RateLimiting/test/RateLimitingMiddlewareTests.cs
@@ -1,11 +1,13 @@
 // 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.RateLimiting;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Testing;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;
+using Moq;
 
 namespace Microsoft.AspNetCore.RateLimiting;
 
@@ -15,19 +17,29 @@ public class RateLimitingMiddlewareTests : LoggedTest
     public void Ctor_ThrowsExceptionsWhenNullArgs()
     {
         var options = CreateOptionsAccessor();
-        options.Value.Limiter = new TestPartitionedRateLimiter<HttpContext>();
+        options.Value.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>();
 
         Assert.Throws<ArgumentNullException>(() => new RateLimitingMiddleware(
             null,
             new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
-            options));
+            options,
+            Mock.Of<IServiceProvider>()));
 
         Assert.Throws<ArgumentNullException>(() => new RateLimitingMiddleware(c =>
-        {
-            return Task.CompletedTask;
-        },
-        null,
-        options));
+            {
+                return Task.CompletedTask;
+            },
+            null,
+            options,
+            Mock.Of<IServiceProvider>()));
+
+        Assert.Throws<ArgumentNullException>(() => new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            null));
     }
 
     [Fact]
@@ -35,14 +47,15 @@ public async Task RequestsCallNextIfAccepted()
     {
         var flag = false;
         var options = CreateOptionsAccessor();
-        options.Value.Limiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(true));
+        options.Value.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(true));
         var middleware = new RateLimitingMiddleware(c =>
-        {
-            flag = true;
-            return Task.CompletedTask;
-        },
-        new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
-        options);
+            {
+                flag = true;
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
 
         await middleware.Invoke(new DefaultHttpContext());
         Assert.True(flag);
@@ -53,19 +66,20 @@ public async Task RequestRejected_CallsOnRejectedAndGives503()
     {
         var onRejectedInvoked = false;
         var options = CreateOptionsAccessor();
-        options.Value.Limiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
-        options.Value.OnRejected = (httpContext, lease) =>
+        options.Value.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
+        options.Value.OnRejected = (context, token) =>
         {
             onRejectedInvoked = true;
-            return Task.CompletedTask;
+            return ValueTask.CompletedTask;
         };
 
         var middleware = new RateLimitingMiddleware(c =>
-        {
-            return Task.CompletedTask;
-        },
-        new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
-        options);
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
 
         var context = new DefaultHttpContext();
         await middleware.Invoke(context).DefaultTimeout();
@@ -78,43 +92,404 @@ public async Task RequestRejected_WinsOverDefaultStatusCode()
     {
         var onRejectedInvoked = false;
         var options = CreateOptionsAccessor();
-        options.Value.Limiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
-        options.Value.OnRejected = (httpContext, lease) =>
+        options.Value.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
+        options.Value.OnRejected = (context, token) =>
         {
             onRejectedInvoked = true;
-            httpContext.Response.StatusCode = 429;
-            return Task.CompletedTask;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
         };
 
+        var middleware = new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.True(onRejectedInvoked);
+        Assert.Equal(StatusCodes.Status429TooManyRequests, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task RequestAborted_ThrowsTaskCanceledException()
+    {
+        var options = CreateOptionsAccessor();
+        options.Value.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
+
+        var middleware = new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        context.RequestAborted = new CancellationToken(true);
+        await Assert.ThrowsAsync<TaskCanceledException>(() => middleware.Invoke(context)).DefaultTimeout();
+    }
+
+    [Fact]
+    public async Task EndpointLimiterRequested_NoPolicy_Throws()
+    {
+        var options = CreateOptionsAccessor();
+        var name = "myEndpoint";
+
         var middleware = new RateLimitingMiddleware(c =>
         {
             return Task.CompletedTask;
         },
-        new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
-        options);
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
 
         var context = new DefaultHttpContext();
+        context.SetEndpoint(new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(name)), "Test endpoint"));
+        await Assert.ThrowsAsync<InvalidOperationException>(() => middleware.Invoke(context)).DefaultTimeout();
+    }
+
+    [Fact]
+    public async Task EndpointLimiter_Rejects()
+    {
+        var onRejectedInvoked = false;
+        var options = CreateOptionsAccessor();
+        var name = "myEndpoint";
+        options.Value.AddPolicy<string>(name, (context =>
+        {
+            return RateLimitPartition.Create<string>("myLimiter", (key =>
+            {
+                return new TestRateLimiter(false);
+            }));
+        }));
+        options.Value.OnRejected = (context, token) =>
+        {
+            onRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        var middleware = new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        context.SetEndpoint(new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(name)), "Test endpoint"));
         await middleware.Invoke(context).DefaultTimeout();
         Assert.True(onRejectedInvoked);
         Assert.Equal(StatusCodes.Status429TooManyRequests, context.Response.StatusCode);
     }
 
     [Fact]
-    public async Task RequestAborted_ThrowsTaskCanceledException()
+    public async Task EndpointLimiterConvenienceMethod_Rejects()
+    {
+        var onRejectedInvoked = false;
+        var options = CreateOptionsAccessor();
+        var name = "myEndpoint";
+        options.Value.AddFixedWindowLimiter(name, new FixedWindowRateLimiterOptions(1, QueueProcessingOrder.OldestFirst, 0, TimeSpan.Zero, autoReplenishment: false));
+        options.Value.OnRejected = (context, token) =>
+        {
+            onRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        var middleware = new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        context.SetEndpoint(new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(name)), "Test endpoint"));
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.False(onRejectedInvoked);
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.True(onRejectedInvoked);
+        Assert.Equal(StatusCodes.Status429TooManyRequests, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task EndpointLimiterRejects_EndpointOnRejectedFires()
+    {
+        var globalOnRejectedInvoked = false;
+        var options = CreateOptionsAccessor();
+        var name = "myEndpoint";
+        // This is the policy that should get used
+        options.Value.AddPolicy<string>(name, new TestRateLimiterPolicy("myKey", 404, false));
+        // This OnRejected should be ignored in favor of the one on the policy
+        options.Value.OnRejected = (context, token) =>
+        {
+            globalOnRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        var middleware = new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        context.SetEndpoint(new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(name)), "Test endpoint"));
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.False(globalOnRejectedInvoked);
+
+        Assert.Equal(StatusCodes.Status404NotFound, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task GlobalAndEndpoint_GlobalRejects_GlobalWins()
+    {
+        var globalOnRejectedInvoked = false;
+        var options = CreateOptionsAccessor();
+        var name = "myEndpoint";
+        // Endpoint always allows - it should not fire
+        options.Value.AddPolicy<string>(name, new TestRateLimiterPolicy("myKey", 404, true));
+        // Global never allows - it should fire
+        options.Value.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
+        options.Value.OnRejected = (context, token) =>
+        {
+            globalOnRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        var middleware = new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        context.SetEndpoint(new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(name)), "Test endpoint"));
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.True(globalOnRejectedInvoked);
+
+        Assert.Equal(StatusCodes.Status429TooManyRequests, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task GlobalAndEndpoint_EndpointRejects_EndpointWins()
     {
+        var globalOnRejectedInvoked = false;
         var options = CreateOptionsAccessor();
-        options.Value.Limiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
+        var name = "myEndpoint";
+        // Endpoint never allows - it should fire
+        options.Value.AddPolicy<string>(name, new TestRateLimiterPolicy("myKey", 404, false));
+        // Global always allows - it should not fire
+        options.Value.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(true));
+        options.Value.OnRejected = (context, token) =>
+        {
+            globalOnRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        var middleware = new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        context.SetEndpoint(new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(name)), "Test endpoint"));
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.False(globalOnRejectedInvoked);
+
+        Assert.Equal(StatusCodes.Status404NotFound, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task GlobalAndEndpoint_BothReject_GlobalWins()
+    {
+        var globalOnRejectedInvoked = false;
+        var options = CreateOptionsAccessor();
+        var name = "myEndpoint";
+        // Endpoint never allows - it should not fire
+        options.Value.AddPolicy<string>(name, new TestRateLimiterPolicy("myKey", 404, false));
+        // Global never allows - it should fire
+        options.Value.GlobalLimiter = new TestPartitionedRateLimiter<HttpContext>(new TestRateLimiter(false));
+        options.Value.OnRejected = (context, token) =>
+        {
+            globalOnRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        var middleware = new RateLimitingMiddleware(c =>
+            {
+                return Task.CompletedTask;
+            },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        context.SetEndpoint(new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(name)), "Test endpoint"));
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.True(globalOnRejectedInvoked);
+
+        Assert.Equal(StatusCodes.Status429TooManyRequests, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task EndpointLimiterRejects_EndpointOnRejectedFires_WithIRateLimiterPolicy()
+    {
+        var globalOnRejectedInvoked = false;
+        var options = CreateOptionsAccessor();
+        var name = "myEndpoint";
+        // This is the policy that should get used
+        options.Value.AddPolicy<string, TestRateLimiterPolicy>(name);
+        // This OnRejected should be ignored in favor of the one on the policy
+        options.Value.OnRejected = (context, token) =>
+        {
+            globalOnRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        // Configure the service provider with the args to the TestRateLimiterPolicy ctor
+        var mockServiceProvider = new Mock<IServiceProvider>();
+        mockServiceProvider
+            .Setup(sp => sp.GetService(typeof(string)))
+            .Returns("myKey");
+        mockServiceProvider
+            .Setup(sp => sp.GetService(typeof(int)))
+            .Returns(404);
+        mockServiceProvider
+            .Setup(sp => sp.GetService(typeof(bool)))
+            .Returns(false);
 
         var middleware = new RateLimitingMiddleware(c =>
         {
             return Task.CompletedTask;
         },
-        new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
-        options);
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            mockServiceProvider.Object);
 
         var context = new DefaultHttpContext();
-        context.RequestAborted = new CancellationToken(true);
-        await Assert.ThrowsAsync<TaskCanceledException>(() => middleware.Invoke(context)).DefaultTimeout();
+        context.SetEndpoint(new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(name)), "Test endpoint"));
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.False(globalOnRejectedInvoked);
+
+        Assert.Equal(StatusCodes.Status404NotFound, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task EndpointLimiter_DuplicatePartitionKey_NoCollision()
+    {
+        var globalOnRejectedInvoked = false;
+        var options = CreateOptionsAccessor();
+        var endpointName1 = "myEndpoint1";
+        var endpointName2 = "myEndpoint2";
+        var duplicateKey = "myKey";
+        // Two policies with the same partition key should not collide, because DefaultKeyType has reference equality
+        options.Value.AddPolicy<string>(endpointName1, new TestRateLimiterPolicy(duplicateKey, 404, false));
+        options.Value.AddPolicy<string>(endpointName2, new TestRateLimiterPolicy(duplicateKey, 400, false));
+        // This OnRejected should be ignored in favor of the ones on the policy
+        options.Value.OnRejected = (context, token) =>
+        {
+            globalOnRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        var middleware = new RateLimitingMiddleware(c =>
+        {
+            return Task.CompletedTask;
+        },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        var endpoint1 = new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(endpointName1)), "Test endpoint 1");
+        var endpoint2 = new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(endpointName2)), "Test endpoint 2");
+
+        context.SetEndpoint(endpoint1);
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.False(globalOnRejectedInvoked);
+        // This should hit endpointName1
+        Assert.Equal(StatusCodes.Status404NotFound, context.Response.StatusCode);
+
+        context.SetEndpoint(endpoint2);
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.False(globalOnRejectedInvoked);
+        // This should hit endpointName2
+        Assert.Equal(StatusCodes.Status400BadRequest, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task EndpointLimiter_DuplicatePartitionKey_Lambda_NoCollision()
+    {
+        var globalOnRejectedInvoked = false;
+        var options = CreateOptionsAccessor();
+        var endpointName1 = "myEndpoint1";
+        var endpointName2 = "myEndpoint2";
+        var duplicateKey = "myKey";
+        // Two policies with the same partition key should not collide, because DefaultKeyType has reference equality
+        options.Value.AddPolicy<string>(endpointName1, key =>
+        {
+            return new RateLimitPartition<string>(duplicateKey, partitionKey =>
+            {
+                return new TestRateLimiter(false);
+            });
+        });
+        options.Value.AddPolicy<string>(endpointName2, key =>
+        {
+            return new RateLimitPartition<string>(duplicateKey, partitionKey =>
+            {
+                return new TestRateLimiter(true);
+            });
+        });
+        options.Value.OnRejected = (context, token) =>
+        {
+            globalOnRejectedInvoked = true;
+            context.HttpContext.Response.StatusCode = 429;
+            return ValueTask.CompletedTask;
+        };
+
+        var middleware = new RateLimitingMiddleware(c =>
+        {
+            return Task.CompletedTask;
+        },
+            new NullLoggerFactory().CreateLogger<RateLimitingMiddleware>(),
+            options,
+            Mock.Of<IServiceProvider>());
+
+        var context = new DefaultHttpContext();
+        var endpoint1 = new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(endpointName1)), "Test endpoint 1");
+        var endpoint2 = new Endpoint(c => Task.CompletedTask, new EndpointMetadataCollection(new RateLimiterMetadata(endpointName2)), "Test endpoint 2");
+
+        context.SetEndpoint(endpoint1);
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.True(globalOnRejectedInvoked);
+        // This should hit endpointName1
+        Assert.Equal(StatusCodes.Status429TooManyRequests, context.Response.StatusCode);
+
+        globalOnRejectedInvoked = false;
+
+        context.SetEndpoint(endpoint2);
+        await middleware.Invoke(context).DefaultTimeout();
+        Assert.False(globalOnRejectedInvoked);
     }
 
     private IOptions<RateLimiterOptions> CreateOptionsAccessor() => Options.Create(new RateLimiterOptions());
diff --git a/src/Middleware/RateLimiting/test/RateLimitingOptionsTests.cs b/src/Middleware/RateLimiting/test/RateLimitingOptionsTests.cs
index 839a9d2da08a..a58512e28f99 100644
--- a/src/Middleware/RateLimiting/test/RateLimitingOptionsTests.cs
+++ b/src/Middleware/RateLimiting/test/RateLimitingOptionsTests.cs
@@ -1,6 +1,8 @@
 // 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.RateLimiting;
+using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
 using Microsoft.AspNetCore.Http;
 
 namespace Microsoft.AspNetCore.RateLimiting;
@@ -8,16 +10,39 @@ namespace Microsoft.AspNetCore.RateLimiting;
 public class RateLimitingOptionsTests
 {
     [Fact]
-    public void ThrowsOnNullLimiter()
+    public void AddPolicy_ThrowsOnNullPolicyName()
     {
         var options = new RateLimiterOptions();
-        Assert.Throws<ArgumentNullException>(() => options.Limiter = null);
+        Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>(null, context => RateLimitPartition.CreateNoLimiter<string>("myKey")));
     }
 
     [Fact]
-    public void ThrowsOnNullOnRejected()
+    public void AddPolicy_ThrowsOnNullPartitioner()
     {
         var options = new RateLimiterOptions();
-        Assert.Throws<ArgumentNullException>(() => options.OnRejected = null);
+        Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>("myKey", partitioner: null));
+    }
+
+    [Fact]
+    public void AddPolicy_ThrowsOnNullPolicy()
+    {
+        var options = new RateLimiterOptions();
+        Assert.Throws<ArgumentNullException>(() => options.AddPolicy<string>("myKey", policy: null));
+    }
+
+    [Fact]
+    public void AddPolicy_ThrowsOnDuplicateName()
+    {
+        var options = new RateLimiterOptions();
+        options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("myKey"));
+        Assert.Throws<ArgumentException>(() => options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("yourKey")));
+    }
+
+    [Fact]
+    public void AddPolicy_Generic_ThrowsOnDuplicateName()
+    {
+        var options = new RateLimiterOptions();
+        options.AddPolicy<string>("myKey", context => RateLimitPartition.CreateNoLimiter<string>("myKey"));
+        Assert.Throws<ArgumentException>(() => options.AddPolicy<string, TestRateLimiterPolicy>("myKey"));
     }
 }
diff --git a/src/Middleware/RateLimiting/test/TestPartitionedRateLimiter.cs b/src/Middleware/RateLimiting/test/TestPartitionedRateLimiter.cs
index 7e3017a95bce..12e21ffbc518 100644
--- a/src/Middleware/RateLimiting/test/TestPartitionedRateLimiter.cs
+++ b/src/Middleware/RateLimiting/test/TestPartitionedRateLimiter.cs
@@ -66,7 +66,7 @@ protected override async ValueTask<RateLimitLease> WaitAsyncCore(TResource resou
         var leases = new List<RateLimitLease>();
         foreach (var limiter in limiters)
         {
-            leases.Add(await limiter.WaitAsync().ConfigureAwait(false));
+            leases.Add(await limiter.WaitAsync());
         }
         foreach (var lease in leases)
         {
diff --git a/src/Middleware/RateLimiting/test/TestRateLimiterPolicy.cs b/src/Middleware/RateLimiting/test/TestRateLimiterPolicy.cs
new file mode 100644
index 000000000000..777935a092f3
--- /dev/null
+++ b/src/Middleware/RateLimiting/test/TestRateLimiterPolicy.cs
@@ -0,0 +1,35 @@
+// 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.RateLimiting;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.RateLimiting;
+internal class TestRateLimiterPolicy : IRateLimiterPolicy<string>
+{
+    private readonly string _key;
+    private readonly bool _alwaysAccept;
+    private readonly Func<OnRejectedContext, CancellationToken, ValueTask> _onRejected;
+
+    public TestRateLimiterPolicy(string key, int statusCode, bool alwaysAccept)
+    {
+        _key = key;
+        _alwaysAccept = alwaysAccept;
+
+        _onRejected = (context, token) =>
+        {
+            context.HttpContext.Response.StatusCode = statusCode;
+            return ValueTask.CompletedTask;
+        };
+    }
+
+    public Func<OnRejectedContext, CancellationToken, ValueTask> OnRejected { get => _onRejected; }
+
+    public RateLimitPartition<string> GetPartition(HttpContext httpContext)
+    {
+        return RateLimitPartition.Create<string>(_key, (key =>
+        {
+            return new TestRateLimiter(_alwaysAccept);
+        }));
+    }
+}