diff --git a/src/frontend/config/sidebar/integrations.topics.ts b/src/frontend/config/sidebar/integrations.topics.ts
index d4f2ea622..3d5ccd80f 100644
--- a/src/frontend/config/sidebar/integrations.topics.ts
+++ b/src/frontend/config/sidebar/integrations.topics.ts
@@ -524,6 +524,10 @@ export const integrationTopics: StarlightSidebarTopicsUserConfig = {
                 },
               ],
             },
+            {
+              label: 'Azure Front Door',
+              slug: 'integrations/cloud/azure/azure-front-door',
+            },
             {
               label: 'Azure Functions',
               collapsed: true,
diff --git a/src/frontend/src/assets/icons/azure-front-door-icon.png b/src/frontend/src/assets/icons/azure-front-door-icon.png
new file mode 100644
index 000000000..8b0f00c07
Binary files /dev/null and b/src/frontend/src/assets/icons/azure-front-door-icon.png differ
diff --git a/src/frontend/src/content/docs/integrations/cloud/azure/azure-front-door.mdx b/src/frontend/src/content/docs/integrations/cloud/azure/azure-front-door.mdx
new file mode 100644
index 000000000..3877141ba
--- /dev/null
+++ b/src/frontend/src/content/docs/integrations/cloud/azure/azure-front-door.mdx
@@ -0,0 +1,206 @@
+---
+title: Azure Front Door
+description: Learn how to use the Aspire Azure Front Door hosting integration to put a global edge in front of your application's backends.
+---
+
+import { Aside } from '@astrojs/starlight/components';
+import InstallPackage from '@components/InstallPackage.astro';
+import { Image } from 'astro:assets';
+import azureIcon from '@assets/icons/azure-front-door-icon.png';
+
+<Image
+  src={azureIcon}
+  alt="Azure Front Door logo"
+  height={80}
+  width={80}
+  class:list={'float-inline-left icon'}
+  data-zoom-off
+/>
+
+[Azure Front Door](https://learn.microsoft.com/azure/frontdoor/) is a global, scalable entry point that uses Microsoft's edge network to deliver fast, secure, and highly available web applications. The Aspire Azure Front Door hosting integration provisions a Front Door profile and routes traffic to your backends.
+
+## Hosting integration
+
+The Aspire Azure Front Door hosting integration models the resource as the following type:
+
+- `AzureFrontDoorResource`: Represents an Azure Front Door profile, including its endpoints, origin groups, origins, and routes.
+
+To access this type and APIs, add the [📦 Aspire.Hosting.Azure.FrontDoor](https://www.nuget.org/packages/Aspire.Hosting.Azure.FrontDoor) NuGet package to your AppHost project.
+
+<InstallPackage packageName="Aspire.Hosting.Azure.FrontDoor" />
+
+### Add an Azure Front Door resource
+
+In your AppHost, call `AddAzureFrontDoor` to add a Front Door profile, then call `WithOrigin` to attach a backend resource as an origin:
+
+```csharp title="C# — AppHost.cs"
+var builder = DistributedApplication.CreateBuilder(args);
+
+builder.AddAzureAppServiceEnvironment("production");
+
+var api = builder.AddProject<Projects.Api>("api")
+    .WithExternalHttpEndpoints();
+
+builder.AddAzureFrontDoor("frontdoor")
+    .WithOrigin(api);
+
+// After adding all resources, run the app...
+builder.Build().Run();
+```
+
+The preceding code:
+
+- Adds an Azure App Service environment (a compute environment is required so Front Door can resolve the origin's hostname).
+- Adds an `api` project and exposes it externally with `WithExternalHttpEndpoints`. Front Door requires an origin to expose an external HTTP or HTTPS endpoint.
+- Adds a Front Door profile named `frontdoor` and configures the `api` project as an origin.
+
+Each call to `WithOrigin` creates a separate Front Door endpoint, origin group, origin, and route, so each backend is independently routable through its own `*.azurefd.net` hostname.
+
+<Aside type="caution">
+  When you call `AddAzureFrontDoor`, it implicitly calls
+  `AddAzureProvisioning`—which adds support for generating Azure resources
+  dynamically during app startup. The app must configure the appropriate
+  subscription and location. For more information, see [Local provisioning:
+  Configuration](/integrations/cloud/azure/local-provisioning/#configuration).
+</Aside>
+
+### Add multiple origins
+
+You can add multiple backends to the same Front Door profile. Each origin gets its own Front Door endpoint and route:
+
+```csharp title="C# — AppHost.cs"
+var builder = DistributedApplication.CreateBuilder(args);
+
+builder.AddAzureAppServiceEnvironment("production");
+
+var api = builder.AddProject<Projects.Api>("api")
+    .WithExternalHttpEndpoints();
+
+var web = builder.AddProject<Projects.Web>("web")
+    .WithExternalHttpEndpoints();
+
+builder.AddAzureFrontDoor("frontdoor")
+    .WithOrigin(api)
+    .WithOrigin(web);
+
+builder.Build().Run();
+```
+
+Each origin must be added at most once per Front Door resource — adding the same resource twice throws `InvalidOperationException`.
+
+### Health probes
+
+Front Door uses health probes to determine which origins are healthy. By default, the Aspire integration probes the origin's external endpoint at path `/` over HTTPS. If you have configured an HTTP probe on the origin (for example with `WithHttpProbe`), Front Door uses the path and protocol from the resource's liveness probe instead.
+
+### Provisioning-generated Bicep
+
+When you publish your app, Aspire generates Bicep alongside the manifest. A Front Door resource with a single origin generates Bicep similar to the following:
+
+```bicep title="Generated Bicep — frontdoor.bicep"
+@description('The location for the resource(s) to be deployed.')
+param location string = resourceGroup().location
+
+param my_api_host string
+
+resource frontdoor 'Microsoft.Cdn/profiles@2025-06-01' = {
+  name: take('frontdoor-${uniqueString(resourceGroup().id)}', 90)
+  location: 'Global'
+  sku: {
+    name: 'Standard_AzureFrontDoor'
+  }
+  tags: {
+    'aspire-resource-name': 'frontdoor'
+  }
+}
+
+resource my_apiEndpoint 'Microsoft.Cdn/profiles/afdEndpoints@2025-06-01' = {
+  name: take('my-api-${uniqueString(resourceGroup().id)}', 46)
+  location: 'Global'
+  parent: frontdoor
+}
+
+resource my_apiOriginGroup 'Microsoft.Cdn/profiles/originGroups@2025-06-01' = {
+  name: take('my-api-og-${uniqueString(resourceGroup().id)}', 90)
+  properties: {
+    healthProbeSettings: {
+      probePath: '/'
+      probeProtocol: 'Https'
+    }
+    loadBalancingSettings: {
+      sampleSize: 4
+      successfulSamplesRequired: 3
+      additionalLatencyInMilliseconds: 50
+    }
+  }
+  parent: frontdoor
+}
+
+resource my_apiOrigin 'Microsoft.Cdn/profiles/originGroups/origins@2025-06-01' = {
+  name: take('my-api-origin-${uniqueString(resourceGroup().id)}', 90)
+  properties: {
+    hostName: my_api_host
+    originHostHeader: my_api_host
+  }
+  parent: my_apiOriginGroup
+}
+
+resource my_apiRoute 'Microsoft.Cdn/profiles/afdEndpoints/routes@2025-06-01' = {
+  name: take('my-api-route-${uniqueString(resourceGroup().id)}', 90)
+  properties: {
+    forwardingProtocol: 'HttpsOnly'
+    httpsRedirect: 'Enabled'
+    linkToDefaultDomain: 'Enabled'
+    originGroup: {
+      id: my_apiOriginGroup.id
+    }
+    patternsToMatch: [
+      '/*'
+    ]
+  }
+  parent: my_apiEndpoint
+  dependsOn: [
+    my_apiOrigin
+  ]
+}
+
+output my_api_endpointUrl string = 'https://${my_apiEndpoint.properties.hostName}'
+```
+
+Aspire passes the origin's hostname (resolved from the compute environment, not the full URL) into the `my_api_host` parameter so the Front Door origin points at the deployed backend.
+
+The generated Bicep is a starting point and is influenced by changes to the provisioning infrastructure in C#. Customizations to the Bicep file directly are overwritten, so make changes through the C# provisioning APIs to ensure they're reflected in the generated files.
+
+#### Customize provisioning infrastructure
+
+For advanced scenarios such as upgrading to the Premium SKU, attaching a Web Application Firewall (WAF) policy, configuring caching, or tuning routes, use `ConfigureInfrastructure` to modify the generated Bicep model directly:
+
+```csharp title="C# — AppHost.cs"
+using Azure.Provisioning.Cdn;
+
+var frontDoor = builder.AddAzureFrontDoor("frontdoor")
+    .WithOrigin(api)
+    .ConfigureInfrastructure(infra =>
+    {
+        var resources = infra.GetProvisionableResources();
+
+        // Upgrade to Premium SKU (required for WAF).
+        var profile = resources.OfType<CdnProfile>().Single();
+        profile.SkuName = CdnSkuName.PremiumAzureFrontDoor;
+
+        // Enable caching on the route.
+        var route = resources.OfType<FrontDoorRoute>().Single();
+        route.CacheConfiguration = new FrontDoorRouteCacheConfiguration
+        {
+            QueryStringCachingBehavior = FrontDoorQueryStringCachingBehavior.IgnoreQueryString
+        };
+    });
+```
+
+For more information, see [Customize Azure resources](/integrations/cloud/azure/customize-resources/). For the full list of configurable properties, see the [Azure.Provisioning.Cdn](https://learn.microsoft.com/dotnet/api/azure.provisioning.cdn) and [Azure.Provisioning.FrontDoor](https://learn.microsoft.com/dotnet/api/azure.provisioning.frontdoor) API documentation.
+
+## See also
+
+- [Azure Front Door documentation](https://learn.microsoft.com/azure/frontdoor/)
+- [Azure Front Door tier comparison](https://learn.microsoft.com/azure/frontdoor/standard-premium/tier-comparison)
+- [Azure App Service integration](/integrations/cloud/azure/azure-app-service/azure-app-service-host/)
+- [Azure integration overview](/integrations/cloud/azure/overview/)
diff --git a/src/frontend/src/content/docs/whats-new/aspire-13-3.mdx b/src/frontend/src/content/docs/whats-new/aspire-13-3.mdx
index e10977e51..0bdf180b0 100644
--- a/src/frontend/src/content/docs/whats-new/aspire-13-3.mdx
+++ b/src/frontend/src/content/docs/whats-new/aspire-13-3.mdx
@@ -9,8 +9,10 @@ tableOfContents:
   maxHeadingLevel: 2
 ---
 
-import { Aside, Steps } from '@astrojs/starlight/components';
+import { Steps } from '@astrojs/starlight/components';
+import { Image } from 'astro:assets';
 import LearnMore from '@components/LearnMore.astro';
+import azureFrontDoorIcon from '@assets/icons/azure-front-door-icon.png';
 
 Welcome to Aspire 13.3! Whether you're a long-time Aspire user or just getting started, we're excited for you to try what's new. If you have questions, feedback, or run into issues, come say hi on [Discord](https://aka.ms/aspire-discord) or open an issue on [GitHub](https://github.com/dotnet/aspire/issues).
 
@@ -39,6 +41,37 @@ The easiest way to upgrade to Aspire 13.3 is using the `aspire update` command:
 
 </Steps>
 
+## Azure Front Door integration
+
+<Image
+  src={azureFrontDoorIcon}
+  alt="Azure Front Door logo"
+  height={80}
+  width={80}
+  class:list={'float-inline-left icon'}
+  data-zoom-off
+/>
+
+Aspire 13.3 adds a new hosting integration for [Azure Front Door](https://learn.microsoft.com/azure/frontdoor/), Microsoft's global edge network for fast, secure, and highly available web apps. Add a Front Door profile in front of your backends with `AddAzureFrontDoor` and attach origins with `WithOrigin`:
+
+```csharp title="C# — AppHost.cs"
+var api = builder.AddProject<Projects.Api>("api")
+    .WithExternalHttpEndpoints();
+
+var web = builder.AddProject<Projects.Web>("web")
+    .WithExternalHttpEndpoints();
+
+builder.AddAzureFrontDoor("frontdoor")
+    .WithOrigin(api)
+    .WithOrigin(web);
+```
+
+Each `WithOrigin` call provisions its own Front Door endpoint, origin group, origin, and route, so every backend is independently routable through its own `*.azurefd.net` hostname. The integration provisions Front Door in the Standard SKU by default; use `ConfigureInfrastructure` to customize the Front Door, for example to change SKUs, attach a Web Application Firewall (WAF) policy, enable caching, and more.
+
+<LearnMore>
+  For more details, see [Azure Front Door integration](/integrations/cloud/azure/azure-front-door/).
+</LearnMore>
+
 ## 🌐 Azure Network Security Perimeter support
 
 Aspire 13.3 adds support for [Azure Network Security Perimeters (NSPs)](https://learn.microsoft.com/azure/private-link/network-security-perimeter-concepts), which provide a logical security boundary for Azure PaaS services. NSPs complement the existing virtual network and private endpoint support by operating at the PaaS layer — grouping resources like Storage, Key Vault, Cosmos DB, and SQL so they can communicate with each other while restricting public access via access rules.
@@ -62,4 +95,6 @@ var keyVault = builder.AddAzureKeyVault("kv")
 
 NSPs support **Enforced** mode (blocks traffic that violates the rules) and **Learning** mode (logs violations without blocking), making it easy to audit traffic before locking down access.
 
-<LearnMore href="/integrations/cloud/azure/azure-virtual-network/#add-a-network-security-perimeter" />
+<LearnMore>
+  For more details, see [Azure Virtual Network integration](/integrations/cloud/azure/azure-virtual-network/#add-a-network-security-perimeter).
+</LearnMore>
