{"id":11636,"date":"2026-01-16T04:00:19","date_gmt":"2026-01-16T12:00:19","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cosmosdb\/?p=11636"},"modified":"2026-02-26T05:15:12","modified_gmt":"2026-02-26T13:15:12","slug":"building-your-first-serverless-http-api-on-azure-with-azure-functions-fastapi","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cosmosdb\/building-your-first-serverless-http-api-on-azure-with-azure-functions-fastapi\/","title":{"rendered":"Part 1: Building Your First Serverless HTTP API on Azure with Azure Functions &#038; FastAPI"},"content":{"rendered":"<h2 aria-level=\"2\"><span data-contrast=\"none\">Introduction<\/span><span data-ccp-props=\"{&quot;134245418&quot;:true,&quot;134245529&quot;:true,&quot;335559738&quot;:160,&quot;335559739&quot;:80}\">\u00a0<\/span><\/h2>\n<p><span data-contrast=\"auto\">This post is\u00a0<\/span>Part 1 of the series <b>Serverless Application Development with Azure Functions and Azure Cosmos DB<\/b><span data-contrast=\"auto\">, where we explore how to build end-to-end serverless applications using Azure Functions for compute and Azure Cosmos DB for storage. Together, these services allow you to build scalable, event-driven, cost-efficient cloud solutions without managing servers or infrastructure.<\/span><span data-ccp-props=\"{&quot;134233117&quot;:false,&quot;134233118&quot;:false,&quot;335551550&quot;:0,&quot;335551620&quot;:0,&quot;335559738&quot;:240,&quot;335559739&quot;:240}\">\u00a0<\/span><\/p>\n<p><span data-contrast=\"auto\">Throughout the series,\u00a0you\u2019ll\u00a0progressively build real application components starting with simple HTTP APIs, adding persistent storage, implementing event-driven patterns using the Cosmos DB Change Feed, and orchestrating workflows with Durable Functions.<\/span><span data-ccp-props=\"{&quot;134233117&quot;:false,&quot;134233118&quot;:false,&quot;335551550&quot;:0,&quot;335551620&quot;:0,&quot;335559738&quot;:240,&quot;335559739&quot;:240}\">\u00a0<\/span><\/p>\n<p><span data-contrast=\"auto\">Posts in this series:\u00a0<\/span><span data-ccp-props=\"{}\">\u00a0<\/span><\/p>\n<ol>\n<li><span data-contrast=\"auto\">Building Your First Serverless HTTP API on Azure with Azure Functions and\u00a0FastAPI<em>\u00a0(this post)<\/em><\/span><em>\u00a0<\/em><\/li>\n<li><a href=\"https:\/\/devblogs.microsoft.com\/cosmosdb\/part-2-building-a-python-crud-api-with-azure-functions-and-azure-cosmos-db\/\"><span data-contrast=\"auto\">Building a Serverless Python CRUD API with Azure Functions and Azure Cosmos DB<\/span><span data-ccp-props=\"{}\">\u00a0<\/span><\/a><\/li>\n<li><span data-contrast=\"auto\">Event-Driven Python Apps with Azure Functions and Cosmos DB Change Feed<\/span><span data-ccp-props=\"{}\">\u00a0<\/span><\/li>\n<li><span data-contrast=\"auto\">Orchestrating Workflows with Durable Functions on Azure<\/span><span data-ccp-props=\"{}\">\u00a0<\/span><\/li>\n<\/ol>\n<h2>Overview of Serverless architecture<\/h2>\n<p>Serverless is a cloud-native development model that lets developers build and run applications while the cloud provider takes care of provisioning, scaling, and maintaining servers. Developers focus on writing business logic and defining the cloud resources their application needs, such as APIs, functions or databases. Once deployed, the cloud provider automatically handles scaling based on demand.<\/p>\n<p>A Serverless model typically follows a pay-as-you-go pricing model, meaning there is no cost when the application is idle. For example, an HTTP API built using a serverless function runs only when a user sends a request. If there are no requests, the application consumes no compute resources and costs nothing.<\/p>\n<p>Key characteristics of a serverless application include:<\/p>\n<ul>\n<li><strong>No server or capacity management<\/strong> \u2013 no need to provision or size machines<\/li>\n<li><strong>Automatic scaling<\/strong> \u2013 scales up or down based on traffic<\/li>\n<li><strong>Pay per use<\/strong> \u2013 you pay only for actual execution<\/li>\n<li><strong>Event-driven execution<\/strong> \u2013 code runs in response to events like HTTP requests, messages, or timers<\/li>\n<\/ul>\n<p>Serverless architecture works especially well for applications with infrequent or unpredictable traffic. It is commonly used to build microservices and event-based systems, and it helps teams move faster by reducing operational overhead and accelerating time to market.<\/p>\n<p>Now that we understand what serverless is, let\u2019s see how it works in practice by building a simple HTTP API using Azure Functions, Azure\u2019s serverless compute service.<\/p>\n<h2>Setup for local development<\/h2>\n<p>To build and run a serverless HTTP API locally on Azure, you\u2019ll need the following tools:<\/p>\n<ol>\n<li><a href=\"https:\/\/www.python.org\/downloads\/release\/python-3110\/\">Python 3.11<\/a> (or later)<\/li>\n<li><a href=\"https:\/\/code.visualstudio.com\/download\">Visual Studio Code<\/a><\/li>\n<li><a href=\"https:\/\/marketplace.visualstudio.com\/items?itemName=ms-azuretools.vscode-azurefunctions\">Azure Functions extension for VS Code<\/a> (for a guided GUI experience)<\/li>\n<li><a href=\"https:\/\/learn.microsoft.com\/en-us\/azure\/azure-functions\/functions-run-local?pivots=programming-language-python\">Azure Functions core tools<\/a> (required to run functions locally)<\/li>\n<\/ol>\n<h2>Building the application<\/h2>\n<p>We\u2019ll build a simple Hello World HTTP API using an HTTP trigger in Azure Functions. An HTTP trigger allows an Azure Function to run in response to an HTTP request, similar to a traditional REST API endpoint. Instead of writing the function from scratch, we\u2019ll use Azure Functions\u2019 Hello World template to get started quickly.<\/p>\n<p>Before we begin writing any code, it\u2019s helpful to visualize how the application works end-to-end. The diagram below shows the flow of an incoming HTTP request from the client, through Azure Functions\u2019 HTTP trigger, into the FastAPI application running behind an ASGI middleware layer. This is the architecture we\u2019ll be building in this tutorial.<\/p>\n<p><a href=\"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-content\/uploads\/sites\/52\/2026\/01\/post-1-1.png\"><img decoding=\"async\" class=\"aligncenter wp-image-11680 size-full\" src=\"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-content\/uploads\/sites\/52\/2026\/01\/post-1-1.png\" alt=\"post 1 image\" width=\"1536\" height=\"515\" srcset=\"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-content\/uploads\/sites\/52\/2026\/01\/post-1-1.png 1536w, https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-content\/uploads\/sites\/52\/2026\/01\/post-1-1-300x101.png 300w, https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-content\/uploads\/sites\/52\/2026\/01\/post-1-1-1024x343.png 1024w, https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-content\/uploads\/sites\/52\/2026\/01\/post-1-1-768x258.png 768w\" sizes=\"(max-width: 1536px) 100vw, 1536px\" \/><\/a><\/p>\n<p><strong>Step 1: Initiate the Azure Functions project<\/strong><\/p>\n<p>Using the Functions CLI (installed via Azure Functions Core Tools), run the following command in a new folder. This creates the base structure and configuration files required for an Azure Functions project.<\/p>\n<p><code>func init funcProject \u2013python<\/code><\/p>\n<p><strong>Step 2: Create an HTTP trigger function<\/strong><\/p>\n<p>Navigate into the project folder and create an HTTP trigger:<\/p>\n<p><code>cd funcProject<\/code><\/p>\n<p><code>func new --name MyHttpFunction --template \"HTTP trigger\"<\/code><\/p>\n<p>This command generates a <code>function_app.py<\/code> file containing the HTTP-triggered function, along with configuration files required by the Azure Functions runtime.<\/p>\n<h3>Understanding the generated files<\/h3>\n<p><strong>host.json<\/strong><\/p>\n<p>The <code>host.json<\/code> file contains global configuration settings that apply to all functions in the app, such as logging and extension versions. Learn more about <a href=\"https:\/\/learn.microsoft.com\/azure\/azure-functions\/functions-host-json\">host.json settings<\/a>.<\/p>\n<p><strong>local.settings.json<\/strong><\/p>\n<p>The <code>local.settings.json<\/code> file stores settings used only for local development, such as environment variables and storage configuration. Learn more about <a href=\"https:\/\/learn.microsoft.com\/azure\/azure-functions\/functions-develop-local?pivots=programming-language-python#local-settings-file\">local.settings.json file in Azure functions project.<\/a><\/p>\n<p>This file is only used for local development and is not deployed to Azure.<\/p>\n<h3>Running the Azure Function locally<\/h3>\n<p><strong>Step 1: Start the Function Runtime<\/strong><\/p>\n<p><code>func start<\/code><\/p>\n<p>You\u2019ll see output similar to:<\/p>\n<p><code>MyHttpFunction: http:\/\/localhost:7071\/api\/MyHttpFunction<\/code><\/p>\n<p><strong>Step 2: Test the HTTP Endpoint <\/strong><\/p>\n<p>Open the URL in a browser or test it using curl or Postman. You should receive the following response:<\/p>\n<p><code>\u201cThis HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.\"<\/code><\/p>\n<h2>Integrating FASTAPI<\/h2>\n<p>Azure Functions provide the production-ready, serverless execution environment, including scaling, availability, and infrastructure management.<\/p>\n<p>FastAPI is a modern, high-performance web framework for building APIs in Python that can be used alongside Azure Functions as an API framework. It helps developers structure endpoints, validate requests, and generate API documentation more easily. Together, Azure Functions and FastAPI combine the operational strengths of serverless computing with the developer experience of a modern web framework.<\/p>\n<p><strong>Step 1: Install FastAPI and Uvicorn <\/strong><\/p>\n<p><code>pip install fastapi uvicorn<\/code><\/p>\n<p><strong>Step 2: Create the FastAPI app (fastapi_app.py)<\/strong><\/p>\n<pre class=\"prettyprint language-py\"><code class=\"language-py\">from fastapi import FastAPI\r\n\r\napp = FastAPI()\r\n\r\n@app.get(\"\/api\/hello\")\r\ndef hello(name: str = \"World\"):\r\n\u00a0 \u00a0 return { f\"Hello, {name}!\"}<\/code><\/pre>\n<p><strong>Step 3: Test the FastAPI app locally <\/strong><\/p>\n<p><code>uvicorn fastapi_app:app<\/code><\/p>\n<p>Open the browser at: <code><a href=\"http:\/\/127.0.0.1:8000\/hello\">http:\/\/127.0.0.1:8000\/api\/hello<\/a><\/code><\/p>\n<p>Expected response: <code>[\"Hello, World!\"]<\/code><\/p>\n<p><strong>Step 4: Forward Azure Function Requests to FastAPI<\/strong><\/p>\n<p>FastAPI is an <strong>ASGI<\/strong> application, while Azure Functions expects a standard HTTP handler. To bridge this gap, Azure provides an <strong>ASGI middleware<\/strong> that forwards incoming HTTP requests to the FastAPI app.<\/p>\n<p>Update the <code>function_app.py<\/code> as follows:<\/p>\n<pre class=\"prettyprint language-py\"><code class=\"language-py\">import azure.functions as func\r\nfrom fastapi import Request\r\nfrom fastapi.responses import Response\r\nfrom fastapi_app import app as fastapi_app\r\nfrom azure.functions._http_asgi import AsgiMiddleware\r\n\r\nfunction_app = func.FunctionApp()\r\n\r\n#Create ASGI middleware to connect Azure Function -&gt; FastAPI\r\nasgi_middleware = AsgiMiddleware(fastapi_app)\r\n\r\n@function_app.route(route=\"{*routes}\", auth_level=func.AuthLevel.ANONYMOUS)\r\nasync def fastapi_handler(req: func.HttpRequest) -&gt; func.HttpResponse:\r\n\u00a0 \u00a0 \"\"\"Proxy all HTTP traffic to FastAPI.\"\"\"\r\n\u00a0 \u00a0 return await asgi_middleware.handle_async(req)<\/code><\/pre>\n<p><strong>Step 5: Test the Integrated Function Locally<\/strong><\/p>\n<p>Run: <code>func start<\/code><\/p>\n<p>Azure Functions automatically prefixes HTTP routes with <code>\/api<\/code>, which is why the endpoint includes <code>\/api\/hello<\/code>.<\/p>\n<p>Test at: <code><a href=\"http:\/\/localhost:7071\/api\/hello\">http:\/\/localhost:7071\/api\/hello<\/a><\/code><\/p>\n<p>Expected response: <code>[\"Hello, World!\"]<\/code><\/p>\n<h2>Adding Request Validation and API Documentation with FastAPI<\/h2>\n<p>So far, our API accepts requests and returns responses, but it doesn\u2019t enforce any structure on the input. One of FastAPI\u2019s key strengths is its ability to automatically validate request data and generate interactive API documentation with minimal effort.<\/p>\n<p>Let\u2019s enhance our API to accept structured input and see these features in action.<\/p>\n<p><strong>Step 1: Define a Request Model<\/strong><\/p>\n<p>FastAPI uses <strong>Pydantic models<\/strong> to define the shape of incoming requests. These models automatically validate the input data.<\/p>\n<p>Add the following code to your <code>fastapi_app.py<\/code> file:<\/p>\n<pre class=\"prettyprint language-py\"><code class=\"language-py\">from pydantic import BaseModel\r\n<\/code><code>class HelloRequest(BaseModel):\r\n<\/code> <code>name: str<\/code><\/pre>\n<p>This model specifies that our API expects a JSON request body containing a name field of type string.<\/p>\n<p><strong>Step 2: Add a POST API Endpoint to Use the Model<\/strong><\/p>\n<p>Next, add the <code>\/helloUser<\/code> endpoint to accept this model as input:<\/p>\n<pre class=\"prettyprint language-py\"><code class=\"language-py\">@app.post(\"\/helloUser\") \r\ndef hello(request: HelloRequest): \u00a0\u00a0\u00a0 \r\n    return {f\"Hello, {request.name}!\"}<\/code><\/pre>\n<p>With this change, FastAPI automatically validates the incoming request. If the request body is missing the name field or has an invalid type, FastAPI returns a clear error response.<\/p>\n<p><strong>Step 3: Test Validation Locally<\/strong><\/p>\n<p>Send a POST request to: <code>http:\/\/localhost:7071\/api\/helloUser<\/code><\/p>\n<p>With the following JSON body: <code>{\"name\": \"Azure\"}<\/code><\/p>\n<p>You should receive: <code>[\"Hello, Azure!\"]<\/code><\/p>\n<p>If you send an invalid request (for example, an empty body), FastAPI automatically returns a validation error explaining what went wrong.<\/p>\n<p><strong>Step 4: Explore the Auto-Generated API Documentation<\/strong><\/p>\n<p>FastAPI generates interactive API documentation based on the application\u2019s routes and schemas. Because Azure Functions modifies HTTP routing, we need to explicitly configure the documentation endpoint. Add the following code to <code>function_app.py<\/code> to make the Swagger UI accessible when running FastAPI with Azure Functions.<\/p>\n<pre class=\"prettyprint language-py\"><code class=\"language-py\">from fastapi.openapi.docs import get_swagger_ui_html\r\n\r\n@fastapi_app.get(\"\/api\/docs\", include_in_schema=False)\r\nasync def custom_swagger_ui_html() -&gt; HTMLResponse:\r\n\u00a0 \u00a0 \"\"\"Custom Swagger UI endpoint that works with Azure Functions.\"\"\"\r\n\u00a0 \u00a0 return get_swagger_ui_html(\r\n\u00a0 \u00a0 \u00a0 \u00a0 openapi_url=\"\",\r\n\u00a0 \u00a0 \u00a0 \u00a0 title=fastapi_app.title + \" - Swagger UI\",\r\n\u00a0 \u00a0 \u00a0 \u00a0 swagger_ui_parameters={\"spec\": fastapi_app.openapi()},\r\n\u00a0 \u00a0 )<\/code><\/pre>\n<p>Open the following URL in your browser: <code><a href=\"http:\/\/localhost:7071\/api\/docs\">http:\/\/localhost:7071\/api\/docs<\/a><\/code><\/p>\n<p>Here, you\u2019ll see all available API endpoints with the expected request and response formats. Swagger UI also provides the ability to test APIs directly from the browser. This documentation is generated automatically from your route definitions and request models, and it stays in sync as your API evolves<em>.<\/em><\/p>\n<h2>Deploying Function app to Azure.<\/h2>\n<p>Now that the function app works locally, let\u2019s deploy it to Azure.<\/p>\n<h4><strong>Prerequisite<\/strong><\/h4>\n<ul>\n<li>An active Azure subscription.<\/li>\n<li>Azure CLI installed (<code>az \u2013-version<\/code>)<\/li>\n<li>Logged in to azure (<code>az login<\/code>)<\/li>\n<\/ul>\n<p><strong>Step1: Create a Resource Group <\/strong><\/p>\n<p><code>az group create --name fastapi-func-rg --location eastus<\/code><\/p>\n<p><strong>Step 2: Create a Storage Account<\/strong><\/p>\n<p>Azure Functions requires a storage account for runtime state and scaling metadata, even if you do not explicitly store data.<\/p>\n<p><code>az storage account create<\/code><code>--name fastapifuncstorage123 --location eastus<\/code><code><\/code><code>--resource-group fastapi-func-rg --sku Standard_LRS<\/code><\/p>\n<p><strong>Step 3: Create the Function App<\/strong><\/p>\n<p><code>az functionapp create--resource-group fastapi-func-rg<\/code><code>--consumption-plan-location eastus --os-type Linux<\/code><code> --runtime python --runtime-version 3.12 --functions-version 4<\/code><code>--name fastapi-function-demo --storage-account fastapifuncstorage123<\/code><\/p>\n<p>This command creates the Azure functions&#8217; Python runtime and uses a consumption (pay-per-use) plan.<\/p>\n<p><strong>Step 5: Deploy the code<\/strong><\/p>\n<p><code>func azure functionapp publish fastapi-function-demo<\/code><\/p>\n<p>During deployment:<\/p>\n<ul>\n<li>The project is packaged and uploaded<\/li>\n<li>Dependencies from requirements.txt are installed<\/li>\n<li>The Function App is restarted<\/li>\n<li>A live endpoint URL is generated<\/li>\n<\/ul>\n<p><strong>Step 6: Test the Deployed API<\/strong><\/p>\n<p>Your API will be available at: <code><a href=\"https:\/\/fastapi-function-demo.azurewebsites.net\/api\/hello\">https:\/\/&lt;function-app-name&gt;.azurewebsites.net\/api\/hello<\/a><\/code><\/p>\n<p>Your FastAPI-powered serverless API is now live on Azure.<\/p>\n<h2>Recap &amp; Next Steps<\/h2>\n<p><span data-contrast=\"auto\">In this post, we built a complete serverless HTTP API on Azure. We introduced serverless architecture, created an HTTP-triggered Azure Function, integrated\u00a0FastAPI\u00a0for routing, validation, and documentation, and deployed the final application to Azure.<\/span><span data-ccp-props=\"{}\">\u00a0<\/span><\/p>\n<p><span data-contrast=\"auto\">In the next post,\u00a0we\u2019ll\u00a0extend this application by persisting data from our HTTP API into a serverless database, exploring how storage and compute work together in a fully serverless architecture.<\/span><span data-ccp-props=\"{}\">\u00a0<\/span><\/p>\n<h2>Resources<\/h2>\n<ul>\n<li>Github sample: <a href=\"https:\/\/github.com\/Azure-Samples\/serverless-python-labs\/tree\/solutions\/solutions\/lab1\">Build HTTP API with Azure Functions and Fast API<\/a><\/li>\n<li>Learn more about Azure Functions: <a href=\"https:\/\/learn.microsoft.com\/en-us\/azure\/azure-functions\/functions-overview\">Azure Functions overview | Microsoft Learn<\/a><\/li>\n<li>Python developer quickstart: <a href=\"https:\/\/learn.microsoft.com\/en-gb\/azure\/azure-functions\/create-first-function-azure-developer-cli?pivots=programming-language-python&amp;tabs=linux%2Cget%2Cbash%2Cpowershell#invoke-the-function-on-azure\">Build a scalable web API using Azure Functions | Microsoft Learn<\/a><\/li>\n<li>Learn more about FastAPI: <a href=\"https:\/\/fastapi.tiangolo.com\/\">FastAPI<\/a><\/li>\n<li>Learn more about Pydantic models: <a href=\"https:\/\/docs.pydantic.dev\/latest\/concepts\/models\/\">Models &#8211; Pydantic Validation<\/a><\/li>\n<\/ul>\n<h3 id=\"about-azure-cosmos-db\"><strong>About Azure Cosmos DB<\/strong><\/h3>\n<p>Azure Cosmos DB is a fully managed and serverless NoSQL and vector database for modern app development, including AI applications. With its SLA-backed speed and availability as well as instant dynamic scalability, it is ideal for real-time NoSQL and MongoDB applications that require high performance and distributed computing over massive volumes of NoSQL and vector data.<\/p>\n<p>To stay in the loop on Azure Cosmos DB updates, follow us on\u00a0<a href=\"https:\/\/twitter.com\/AzureCosmosDB\" target=\"_blank\" rel=\"noopener\">X<\/a>,\u00a0<a href=\"https:\/\/aka.ms\/AzureCosmosDBYouTube\" target=\"_blank\" rel=\"noopener\">YouTube<\/a>, and\u00a0<a href=\"https:\/\/www.linkedin.com\/company\/azure-cosmos-db\/\" target=\"_blank\" rel=\"noopener\">LinkedIn<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Introduction\u00a0 This post is\u00a0Part 1 of the series Serverless Application Development with Azure Functions and Azure Cosmos DB, where we explore how to build end-to-end serverless applications using Azure Functions for compute and Azure Cosmos DB for storage. Together, these services allow you to build scalable, event-driven, cost-efficient cloud solutions without managing servers or infrastructure.\u00a0 [&hellip;]<\/p>\n","protected":false},"author":90111,"featured_media":11707,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[14,1940],"tags":[496,1312,1177],"class_list":["post-11636","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-core-sql-api","category-serverless","tag-azure-functions","tag-python","tag-serverless"],"acf":[],"blog_post_summary":"<p>Introduction\u00a0 This post is\u00a0Part 1 of the series Serverless Application Development with Azure Functions and Azure Cosmos DB, where we explore how to build end-to-end serverless applications using Azure Functions for compute and Azure Cosmos DB for storage. Together, these services allow you to build scalable, event-driven, cost-efficient cloud solutions without managing servers or infrastructure.\u00a0 [&hellip;]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/posts\/11636","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/users\/90111"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/comments?post=11636"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/posts\/11636\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/media\/11707"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/media?parent=11636"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/categories?post=11636"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cosmosdb\/wp-json\/wp\/v2\/tags?post=11636"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}