How to Configure FastAPI for XML Responses in Documentation

FastAPI is a modern, high-performance web framework for building APIs with Python 3.6+ based on standard Python-type hints. It is designed to be easy to use while delivering great performance. FastAPI automatically generates interactive API documentation using the OpenAPI standard, which is one of its most impressive features. However, when it comes to returning XML responses instead of the typical JSON, developers often face challenges. In this article, we will guide you on how to configure FastAPI to handle XML responses for API calls, aiming to enhance the usability and integration of your APIs.

Overview of FastAPI and its Features

Why FastAPI?

FastAPI provides several key features that make it a great choice for building APIs:
– Automatic interactive API documentation: FastAPI generates documentation using Swagger UI and ReDoc.
– Fast (high-performance): The underlying ASGI server, Uvicorn, ensures rapid request handling.
– Easy and intuitive: With Python-type hints, it becomes straightforward to define request parameters and validate them easily.
– Built-in security: FastAPI supports various authentication mechanisms, including Basic Identity Authentication and APIKey.

API Specifications

FastAPI’s API specifications are critical for developers and users to understand how to interact with your API. Configuring the API to return XML responses can cater to specific use cases where XML is the preferred data format.

Setting Up FastAPI for XML Responses

Installation of FastAPI and Required Libraries

Before diving into XML response configuration, ensure you have FastAPI and an ASGI server running. You can set this up with the following command:

pip install fastapi uvicorn lxml

The lxml library will help in constructing XML responses efficiently.

Creating Your FastAPI Application

Start by creating a simple FastAPI application. Below is a basic application setup:

from fastapi import FastAPI, Response
from fastapi.responses import XMLResponse
import xml.etree.ElementTree as ET

app = FastAPI()

@app.get("/items/{item_id}", response_class=XMLResponse)
async def read_item(item_id: int):
    item = {"item_id": item_id, "name": "Item Name", "description": "Item Description"}

    # Create XML structure
    root = ET.Element("item")
    for key, value in item.items():
        child = ET.SubElement(root, key)
        child.text = str(value)

    xml_str = ET.tostring(root, encoding='utf-8', xml_declaration=True)
    return Response(content=xml_str, media_type="application/xml")

In the example above, we defined a route that returns XML data. The XMLResponse class is utilized to specify the response type explicitly.

Testing the Application

To run the FastAPI app, save it as main.py, and execute the following command:

uvicorn main:app --reload

Now, you can visit http://127.0.0.1:8000/items/1 to see the XML response.

FastAPI Documentation and XML Responses

FastAPI automatically generates API documentation through Swagger UI, located at http://127.0.0.1:8000/docs or ReDoc at http://127.0.0.1:8000/redoc.

However, the auto-generated documentation may default to showing the response type as JSON. To enhance clarity and documentation integrity, you can manually define the response type for XML.

Defining XML Response in Documentation

You can specify the expected response type in the provided decorators. Here’s how to do it:

from fastapi import FastAPI, Response
from fastapi.responses import XMLResponse
from fastapi import Query

app = FastAPI()

@app.get("/items/{item_id}", response_class=XMLResponse, responses={200: {"content": {"application/xml": {}}}})
async def read_item(item_id: int, q: str = Query(None)):
    item = {"item_id": item_id, "name": "Item Name", "description": "Item Description"}

    # Create XML structure
    root = ET.Element("item")
    for key, value in item.items():
        child = ET.SubElement(root, key)
        child.text = str(value)

    xml_str = ET.tostring(root, encoding='utf-8', xml_declaration=True)
    return Response(content=xml_str, media_type="application/xml")

View XML Documentation

When you now visit the automatic documentation endpoints, you will notice that the response format is explicitly described as application/xml.

API Gateway Configuration with NGINX

With your FastAPI application returning XML responses successfully, you may wish to route these APIs through an API Gateway for better management, security, and scalability. NGINX can serve as an effective API Gateway.

NGINX Installation

If you don’t have NGINX installed, you can run:

sudo apt update
sudo apt install nginx

Basic NGINX Configuration

Create or edit your NGINX configuration file located in /etc/nginx/sites-available/default or a custom config file.

Here’s an example configuration:

server {
    listen 80;
    server_name yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Handle XML response
        add_header Content-Type application/xml;
    }
}

Testing the API Through NGINX

Make sure to test your NGINX configuration for syntax errors and restart the service:

sudo nginx -t
sudo systemctl restart nginx

You can now access your FastAPI application through your domain with XML responses being served correctly.

Adding Authentication to Your API

Security is vital for any API service. FastAPI has built-in support for Basic Identity Authentication and APIKey methods, which can be integrated into our application.

Basic Identity Authentication

You can use FastAPI’s dependency injection system to require a username and password for accessing certain endpoints.

from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBasic, HTTPBasicCredentials

security = HTTPBasic()

def verify_credentials(credentials: HTTPBasicCredentials = Depends(security)):
    if credentials.username != "user" or credentials.password != "password":
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials", headers={"WWW-Authenticate": "Basic"})

Integrate this with your XML endpoint:

@app.get("/items/{item_id}", response_class=XMLResponse, dependencies=[Depends(verify_credentials)])
async def read_item(item_id: int):
    ...

APIKey Authentication

Another common method of authentication is using API keys. You can define an APIKey dependency as shown below:

from fastapi import Header, Query

async def api_key_auth(api_key: str = Header(...)):
    if api_key != "YOUR_API_KEY":
        raise HTTPException(status_code=403, detail="API Key not valid.")

Modify your endpoint to utilize this security feature:

@app.get("/items/{item_id}", response_class=XMLResponse, dependencies=[Depends(api_key_auth)])
async def read_item(item_id: int):
    ...

Conclusion

Configuring FastAPI for XML responses opens a realm of integration possibilities, especially when XML is a requirement for clients consuming your API. By leveraging FastAPI’s built-in functionality, you can ensure your API documentation is accurate and provides necessary information on how to manage XML responses effectively.

Incorporating security measures such as Basic Identity Authentication and API keys further ensures that your API remains robust and securely accessible.

Summary Table of Key Features

APIPark is a high-performance AI gateway that allows you to securely access the most comprehensive LLM APIs globally on the APIPark platform, including OpenAI, Anthropic, Mistral, Llama2, Google Gemini, and more.Try APIPark now! 👇👇👇

Now that you have a solid foundation, continue to explore FastAPI’s features and expand your application’s capabilities. By mastering these techniques, you will be able to build secure, efficient APIs with rich documentation, serving clients that require XML and more.

Implementing this combined knowledge allows you to deliver high-quality services that meet the demands of modern applications. Whether it’s enhancing security or ensuring data format compliance, mastering these elements will establish a strong baseline for your future API projects.

🚀You can securely and efficiently call the Wenxin Yiyan API on APIPark in just two steps:

Step 1: Deploy the APIPark AI gateway in 5 minutes.

APIPark is developed based on Golang, offering strong product performance and low development and maintenance costs. You can deploy APIPark with a single command line.

curl -sSO https://download.apipark.com/install/quick-start.sh; bash quick-start.sh

In my experience, you can see the successful deployment interface within 5 to 10 minutes. Then, you can log in to APIPark using your account.

Step 2: Call the Wenxin Yiyan API.