PlainTextResponse

Return plain text content with the PlainTextResponse class

Overview

PlainTextResponse is a response class that returns plain text content with the text/plain media type. It’s useful when you need to return raw text data without HTML markup or JSON serialization.

Import

from fastapi.responses import PlainTextResponse

Signature

PlainTextResponse(
    content: str | bytes,
    status_code: int = 200,
    headers: dict[str, str] | None = None,
    media_type: str = "text/plain",
    background: BackgroundTask | None = None,
)

Parameters

content · str | bytes · required

The plain text content to return

status_code · int · default: "200"

HTTP status code

headers · dict[str, str] | None

Additional HTTP headers

media_type · str · default: "text/plain"

Media type for the response

background · BackgroundTask | None

Background task to run after sending the response

Properties

media_type · str

Always "text/plain" unless explicitly overridden

Usage

Basic plain text response

from fastapi import FastAPI
from fastapi.responses import PlainTextResponse

app = FastAPI()

@app.get("/text")
def get_text():
    return PlainTextResponse("Hello, World!")

Using response_class parameter

@app.get("/text", response_class=PlainTextResponse)
def get_text():
    return "Hello, World!"

When using response_class=PlainTextResponse, you can return a string directly without wrapping it in PlainTextResponse().

With custom status code

@app.get("/error")
def get_error():
    return PlainTextResponse(
        content="An error occurred",
        status_code=500
    )

With custom headers

@app.get("/text-with-headers")
def get_text_with_headers():
    return PlainTextResponse(
        content="Hello, World!",
        headers={"X-Custom-Header": "value"}
    )

With background task

from fastapi import BackgroundTasks

def log_request(message: str):
    print(f"Logged: {message}")

@app.get("/text-with-task")
def get_text_with_task(background_tasks: BackgroundTasks):
    background_tasks.add_task(log_request, "Request completed")
    return PlainTextResponse("Processing...")

Use cases

Log files

Return log file contents as plain text

Configuration

Return configuration files or environment data

Text data

Return CSV, TSV, or other text-based formats

Debug output

Return debugging information as plain text

Example: Returning a text file

@app.get("/logs", response_class=PlainTextResponse)
def get_logs():
    with open("app.log", "r") as f:
        return f.read()

Example: CSV data

@app.get("/users.csv", response_class=PlainTextResponse)
def export_users():
    csv_data = "id,name,email\n1,John Doe,[e-mail]\n2,Jane Smith,[e-mail]"
    return PlainTextResponse(
        content=csv_data,
        media_type="text/csv",
        headers={"Content-Disposition": "attachment; filename=users.csv"}
    )

While you can set a custom media_type, consider using FileResponse for actual file downloads with proper headers.

Comparison with other response types

• JSONResponse: Use for structured data that needs to be parsed
• HTMLResponse: Use for HTML content to be rendered in a browser
• PlainTextResponse: Use for raw text data, logs, or simple text formats

Related

• JSONResponse - Return JSON data
• HTMLResponse - Return HTML content
• FileResponse - Return files for download
• Response - Base response class