FastAPI is a modern, high-performance web framework for building APIs with Python. It is designed to be easy to use and learn while providing powerful features like automatic validation, serialization, and automatic interactive API documentation. Additionally, it works with any template engine and allows you to use any default template configuration needed for your project.

Let's dive into the details of FastAPI, its features, and how to use it effectively. Later in this article, we will also look into IronPDF, a PDF generation Python package from Iron Software.

Key Features of FastAPI

1. High Performance: FastAPI is one of the fastest Python frameworks available, comparable to Node.js and Go, thanks to its use of Starlette for the web parts and Pydantic for the data parts.
2. Ease of Use: It is designed to be intuitive and reduce the time spent reading documentation. The framework leverages standard Python-type hints for data validation and serialization.
3. Automatic Interactive Documentation: FastAPI automatically generates interactive API documentation using OpenAPI and JSON Schema, accessible via /docs (Swagger UI) and /redoc (ReDoc). Any updates to the API are automatically reflected in the documentation.
4. Editor Support: Excellent support for code completion and type checking in editors like VS Code, making development faster and reducing errors.
5. Standards-Based: It is based on (and fully compatible with) the open standards for APIs: OpenAPI and JSON Schema.

Installation

You can install FastAPI and Uvicorn (an ASGI server) using pip:

pip install fastapi
pip install "uvicorn[standard]"

pip install fastapi
pip install "uvicorn[standard]"

Creating Your First FastAPI Application

Here's a simple example to get you started with FastAPI and expose Python data through a user interface:

from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

To run the application, use Uvicorn:

uvicorn main:app --reload

uvicorn main:app --reload

This command will start a development server and automatically reload for code changes. You can access the interactive API documentation at http://127.0.0.1:8000/docs.

Advanced Features

FastAPI supports a wide range of advanced features, making it suitable for complex applications:

1. Dependency Injection: FastAPI provides a powerful dependency injection system that allows you to manage dependencies cleanly and efficiently.
2. Background Tasks: You can define background tasks to be run after returning a response, useful for tasks like sending emails or processing data.
3. WebSockets: FastAPI supports WebSockets, enabling real-time communication between the client and server.
4. Security: FastAPI includes tools for handling security, including OAuth2, JWT tokens, and more.
5. Database Integration: FastAPI can be easily integrated with databases using libraries like SQLAlchemy or Tortoise-ORM.

Example: Building a CRUD API

Let's build a simple CRUD (Create, Read, Update, Delete) API for managing items.

1. Define the Data Model:

   from pydantic import BaseModel
   
   # Define a Pydantic model for the item with default description and tax
   class Item(BaseModel):
       name: str
       description: str = None
       price: float
       tax: float = None

   Python

2. Create the FastAPI Application:

   from fastapi import FastAPI, HTTPException
   
   # Initialize 'app' instance and an empty 'items' dictionary
   app = FastAPI()
   items = {}
   
   # Create operation: Add a new item
   @app.post("/items/")
   def create_item(item: Item):
       item_id = len(items) + 1
       items[item_id] = item
       return item
   
   # Read operation: Retrieve an item by 'item_id'
   @app.get("/items/{item_id}")
   def read_item(item_id: int):
       if item_id not in items:
           raise HTTPException(status_code=404, detail="Item not found")
       return items[item_id]
   
   # Update operation: Replace an existing item
   @app.put("/items/{item_id}")
   def update_item(item_id: int, item: Item):
       if item_id not in items:
           raise HTTPException(status_code=404, detail="Item not found")
       items[item_id] = item
       return item
   
   # Delete operation: Remove an item by 'item_id'
   @app.delete("/items/{item_id}")
   def delete_item(item_id: int):
       if item_id not in items:
           raise HTTPException(status_code=404, detail="Item not found")
       del items[item_id]
       return {"message": "Item deleted"}

   Python

Introducing IronPDF

IronPDF is a powerful Python library designed for creating, editing, and signing PDFs from HTML, CSS, images, and JavaScript. It offers commercial-grade performance with a low memory footprint. Key features include:

HTML to PDF Conversion

Convert HTML files, HTML strings, and URLs to PDFs. For example, render a webpage as a PDF using the Chrome PDF renderer.

Cross-Platform Support

Compatible with various .NET platforms, including .NET Core, .NET Standard, and .NET Framework. It supports Windows, Linux, and macOS.

Editing and Signing

Set properties, add security with passwords and permissions, and apply digital signatures to your PDFs.

Page Templates and Settings

Customize PDFs with headers, footers, page numbers, and adjustable margins. Supports responsive layouts and custom paper sizes.

Standards Compliance

Adheres to PDF standards such as PDF/A and PDF/UA. Supports UTF-8 character encoding and handles assets like images, CSS, and fonts.

Generate PDF Documents using IronPDF and FastAPI

pip install fastapi ironpdf

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    
    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")
    
    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    
    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")
    
    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)

Code Explanation

This code snippet demonstrates the integration of IronPDF with FastAPI to dynamically generate PDF documents based on user inputs and serve them as a downloadable response.

1. Setting License Key: Applies the IronPDF license key to enable its features.
2. FastAPI Initialization: Initializes a FastAPI instance (app) to handle HTTP requests.
3. Basic Route Handlers:
   • read_root(): Responds with a simple JSON message indicating "Hello IronPDF" when accessing the root URL (/).
   • read_item(): Accepts an item_id path parameter and an optional q query parameter. Returns a JSON response with these parameters.
4. PDF Generation Route (/pdf):
   • get_pdf(): This async function handles GET requests to the /pdf endpoint with optional query parameters named greet1 and greet2.
   • Constructs an HTML string (content) that includes:
     • A header indicating the document's origin and purpose.
     • A paragraph demonstrating PDF generation using user inputs (greet1 and greet2).
   • Uses ChromePdfRenderer() from IronPDF to render the HTML content into a PDF (pdf = renderer.RenderHtmlAsPdf(content)).
   • Saves the generated PDF as "fastapi.pdf" (pdf.SaveAs("fastapi.pdf")).
5. Serving the PDF:
   • Configures response headers to specify that the PDF should be viewed inline in the browser ("Content-Disposition": "inline; filename=sample.pdf").
   • Creates a FileResponse object pointing to the generated PDF file with the appropriate media type ("application/pdf").
   • Returns the FileResponse object, which triggers the download of the PDF document when the /pdf endpoint is accessed.

This code snippet illustrates how IronPDF can be seamlessly integrated with FastAPI to dynamically generate and serve PDF documents based on user inputs. It showcases the ability to convert HTML content into PDFs, making it suitable for applications requiring on-the-fly document generation and delivery over HTTP.

Output

Below shows the swagger output generated from the APIs

PDF

IronPDF License

IronPDF runs on the license key for Python. IronPDF for Python offers a free trial license key to allow users to check out features before purchase.

Place the License Key at the start of the script before using the IronPDF package:

from ironpdf import *
# Apply your license key
License.LicenseKey = "key"

from ironpdf import *
# Apply your license key
License.LicenseKey = "key"

Conclusion

FastAPI is a powerful and easy-to-use framework for building APIs in Python. FastAPI has high performance, automatic documentation, and advanced features make it an excellent choice for both beginners and experienced developers. Whether you're building a simple API or a complex web application, FastAPI provides the tools you need to succeed.

IronPDF is a robust Python library for creating, manipulating, and rendering PDF documents from HTML content. It offers features like HTML to PDF conversion, interactive form creation, PDF manipulation (merging, splitting), and text extraction. Ideal for generating dynamic PDFs with ease and integrating into various Python applications.