diff --git a/frigate/api/app.py b/frigate/api/app.py
index 66e2522cd..62e37131f 100644
--- a/frigate/api/app.py
+++ b/frigate/api/app.py
@@ -23,7 +23,6 @@ from frigate.api.auth import AuthBp, get_jwt_secret, limiter
 from frigate.api.defs.tags import Tags
 from frigate.api.event import EventBp
 from frigate.api.export import ExportBp
-from frigate.api.media import MediaBp
 from frigate.api.notification import NotificationBp
 from frigate.api.review import ReviewBp
 from frigate.config import FrigateConfig
@@ -49,7 +48,6 @@ logger = logging.getLogger(__name__)
 bp = Blueprint("frigate", __name__)
 bp.register_blueprint(EventBp)
 bp.register_blueprint(ExportBp)
-bp.register_blueprint(MediaBp)
 bp.register_blueprint(ReviewBp)
 bp.register_blueprint(AuthBp)
 bp.register_blueprint(NotificationBp)
diff --git a/frigate/api/fastapi_app.py b/frigate/api/fastapi_app.py
index bda938f2b..9dd7b0610 100644
--- a/frigate/api/fastapi_app.py
+++ b/frigate/api/fastapi_app.py
@@ -3,7 +3,7 @@ import logging
 from fastapi import FastAPI
 
 from frigate.api import app as main_app
-from frigate.api import preview
+from frigate.api import media, preview
 from frigate.plus import PlusApi
 from frigate.ptz.onvif import OnvifController
 from frigate.stats.emitter import StatsEmitter
@@ -21,9 +21,13 @@ def create_fastapi_app(
     stats_emitter: StatsEmitter,
 ):
     logger.info("Starting FastAPI app")
-    app = FastAPI(debug=False)
+    app = FastAPI(
+        debug=False,
+        swagger_ui_parameters={"apisSorter": "alpha", "operationsSorter": "alpha"},
+    )
     # Routes
     app.include_router(main_app.router)
+    app.include_router(media.router)
     app.include_router(preview.router)
     # App Properties
     app.frigate_config = frigate_config
diff --git a/frigate/api/media.py b/frigate/api/media.py
index 092958581..edeece263 100644
--- a/frigate/api/media.py
+++ b/frigate/api/media.py
@@ -2,21 +2,25 @@
 
 import base64
 import glob
+import io
 import logging
 import os
 import subprocess as sp
 import time
 from datetime import datetime, timedelta, timezone
+from typing import Optional
 from urllib.parse import unquote
 
 import cv2
 import numpy as np
 import pytz
-from flask import Blueprint, Response, current_app, jsonify, make_response, request
+from fastapi import APIRouter, Path, Query, Request, Response
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
 from peewee import DoesNotExist, fn
 from tzlocal import get_localzone_name
 from werkzeug.utils import secure_filename
 
+from frigate.api.defs.tags import Tags
 from frigate.const import (
     CACHE_DIR,
     CLIPS_DIR,
@@ -30,41 +34,53 @@ from frigate.util.image import get_image_from_recording
 
 logger = logging.getLogger(__name__)
 
-MediaBp = Blueprint("media", __name__)
+
+router = APIRouter(tags=[Tags.media])
 
 
-@MediaBp.route("/<camera_name>")
-def mjpeg_feed(camera_name):
-    fps = int(request.args.get("fps", "3"))
-    height = int(request.args.get("h", "360"))
+@router.get("/media/camera/{camera_name}")
+def mjpeg_feed(
+    request: Request,
+    camera_name: str,
+    fps: int = 3,
+    height: int = 360,
+    bbox: Optional[int] = None,
+    timestamp: Optional[int] = None,
+    zones: Optional[int] = None,
+    mask: Optional[int] = None,
+    motion: Optional[int] = None,
+    regions: Optional[int] = None,
+):
     draw_options = {
-        "bounding_boxes": request.args.get("bbox", type=int),
-        "timestamp": request.args.get("timestamp", type=int),
-        "zones": request.args.get("zones", type=int),
-        "mask": request.args.get("mask", type=int),
-        "motion_boxes": request.args.get("motion", type=int),
-        "regions": request.args.get("regions", type=int),
+        "bounding_boxes": bbox,
+        "timestamp": timestamp,
+        "zones": zones,
+        "mask": mask,
+        "motion_boxes": motion,
+        "regions": regions,
     }
-    if camera_name in current_app.frigate_config.cameras:
+    if camera_name in request.app.frigate_config.cameras:
         # return a multipart response
-        return Response(
+        return StreamingResponse(
             imagestream(
-                current_app.detected_frames_processor,
+                request.app.detected_frames_processor,
                 camera_name,
                 fps,
                 height,
                 draw_options,
             ),
-            mimetype="multipart/x-mixed-replace; boundary=frame",
+            media_type="multipart/x-mixed-replace;boundary=frame",
         )
     else:
-        return make_response(
-            jsonify({"success": False, "message": "Camera not found"}),
-            404,
+        return JSONResponse(
+            content={"success": False, "message": "Camera not found"},
+            status_code=404,
         )
 
 
-def imagestream(detected_frames_processor, camera_name, fps, height, draw_options):
+def imagestream(
+    detected_frames_processor, camera_name: str, fps: int, height: int, draw_options
+):
     while True:
         # max out at specified FPS
         time.sleep(1 / fps)
@@ -78,122 +94,136 @@ def imagestream(detected_frames_processor, camera_name, fps, height, draw_option
         ret, jpg = cv2.imencode(".jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 70])
         yield (
             b"--frame\r\n"
-            b"Content-Type: image/jpeg\r\n\r\n" + jpg.tobytes() + b"\r\n\r\n"
+            b"Content-Type: image/jpeg\r\n\r\n" + bytearray(jpg.tobytes()) + b"\r\n\r\n"
         )
 
 
-@MediaBp.route("/<camera_name>/ptz/info")
-def camera_ptz_info(camera_name):
-    if camera_name in current_app.frigate_config.cameras:
-        return jsonify(current_app.onvif.get_camera_info(camera_name))
+@router.get("/media/camera/{camera_name}/ptz/info")
+def camera_ptz_info(request: Request, camera_name: str):
+    if camera_name in request.app.frigate_config.cameras:
+        return JSONResponse(
+            content=request.app.onvif.get_camera_info(camera_name),
+        )
     else:
-        return make_response(
-            jsonify({"success": False, "message": "Camera not found"}),
-            404,
+        return JSONResponse(
+            content={"success": False, "message": "Camera not found"},
+            status_code=404,
         )
 
 
-@MediaBp.route("/<camera_name>/latest.jpg")
-@MediaBp.route("/<camera_name>/latest.webp")
-def latest_frame(camera_name):
+@router.get("/media/camera/{camera_name}/frame/latest")
+def latest_frame(
+    request: Request,
+    camera_name: str,
+    extension: Optional[str] = Query("webp", enum=["webp", "png", "jpg", "jpeg"]),
+    bbox: Optional[int] = None,
+    timestamp: Optional[int] = None,
+    zones: Optional[int] = None,
+    mask: Optional[int] = None,
+    motion: Optional[int] = None,
+    regions: Optional[int] = None,
+    quality: Optional[int] = 70,
+    height: Optional[int] = None,
+):
     draw_options = {
-        "bounding_boxes": request.args.get("bbox", type=int),
-        "timestamp": request.args.get("timestamp", type=int),
-        "zones": request.args.get("zones", type=int),
-        "mask": request.args.get("mask", type=int),
-        "motion_boxes": request.args.get("motion", type=int),
-        "regions": request.args.get("regions", type=int),
+        "bounding_boxes": bbox,
+        "timestamp": timestamp,
+        "zones": zones,
+        "mask": mask,
+        "motion_boxes": motion,
+        "regions": regions,
     }
-    resize_quality = request.args.get("quality", default=70, type=int)
-    extension = os.path.splitext(request.path)[1][1:]
 
-    if camera_name in current_app.frigate_config.cameras:
-        frame = current_app.detected_frames_processor.get_current_frame(
+    if camera_name in request.app.frigate_config.cameras:
+        frame = request.app.detected_frames_processor.get_current_frame(
             camera_name, draw_options
         )
         retry_interval = float(
-            current_app.frigate_config.cameras.get(camera_name).ffmpeg.retry_interval
+            request.app.frigate_config.cameras.get(camera_name).ffmpeg.retry_interval
             or 10
         )
 
         if frame is None or datetime.now().timestamp() > (
-            current_app.detected_frames_processor.get_current_frame_time(camera_name)
+            request.app.detected_frames_processor.get_current_frame_time(camera_name)
             + retry_interval
         ):
-            if current_app.camera_error_image is None:
+            if request.app.camera_error_image is None:
                 error_image = glob.glob("/opt/frigate/frigate/images/camera-error.jpg")
 
                 if len(error_image) > 0:
-                    current_app.camera_error_image = cv2.imread(
+                    request.app.camera_error_image = cv2.imread(
                         error_image[0], cv2.IMREAD_UNCHANGED
                     )
 
-            frame = current_app.camera_error_image
+            frame = request.app.camera_error_image
 
-        height = int(request.args.get("h", str(frame.shape[0])))
+        height = int(height or str(frame.shape[0]))
         width = int(height * frame.shape[1] / frame.shape[0])
 
         if frame is None:
-            return make_response(
-                jsonify({"success": False, "message": "Unable to get valid frame"}),
-                500,
+            return JSONResponse(
+                content={"success": False, "message": "Unable to get valid frame"},
+                status_code=500,
             )
 
         if height < 1 or width < 1:
-            return (
-                "Invalid height / width requested :: {} / {}".format(height, width),
-                400,
+            return JSONResponse(
+                content="Invalid height / width requested :: {} / {}".format(
+                    height, width
+                ),
+                status_code=400,
             )
 
         frame = cv2.resize(frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
 
         ret, img = cv2.imencode(
-            f".{extension}", frame, [int(cv2.IMWRITE_WEBP_QUALITY), resize_quality]
+            f".{extension}", frame, [int(cv2.IMWRITE_WEBP_QUALITY), quality]
         )
-        response = make_response(img.tobytes())
-        response.headers["Content-Type"] = f"image/{extension}"
-        response.headers["Cache-Control"] = "no-store"
-        return response
-    elif camera_name == "birdseye" and current_app.frigate_config.birdseye.restream:
+        return StreamingResponse(
+            io.BytesIO(img.tobytes()),
+            media_type=f"image/{extension}",
+            headers={"Content-Type": f"image/{extension}", "Cache-Control": "no-store"},
+        )
+    elif camera_name == "birdseye" and request.app.frigate_config.birdseye.restream:
         frame = cv2.cvtColor(
-            current_app.detected_frames_processor.get_current_frame(camera_name),
+            request.app.detected_frames_processor.get_current_frame(camera_name),
             cv2.COLOR_YUV2BGR_I420,
         )
 
-        height = int(request.args.get("h", str(frame.shape[0])))
+        height = int(height or str(frame.shape[0]))
         width = int(height * frame.shape[1] / frame.shape[0])
 
         frame = cv2.resize(frame, dsize=(width, height), interpolation=cv2.INTER_AREA)
 
         ret, img = cv2.imencode(
-            f".{extension}", frame, [int(cv2.IMWRITE_WEBP_QUALITY), resize_quality]
+            f".{extension}", frame, [int(cv2.IMWRITE_WEBP_QUALITY), quality]
+        )
+        return StreamingResponse(
+            io.BytesIO(img.tobytes()),
+            media_type=f"image/{extension}",
+            headers={"Content-Type": f"image/{extension}", "Cache-Control": "no-store"},
         )
-        response = make_response(img.tobytes())
-        response.headers["Content-Type"] = f"image/{extension}"
-        response.headers["Cache-Control"] = "no-store"
-        return response
     else:
-        return make_response(
-            jsonify({"success": False, "message": "Camera not found"}),
-            404,
+        return JSONResponse(
+            content={"success": False, "message": "Camera not found"},
+            status_code=404,
         )
 
 
-@MediaBp.route("/<camera_name>/recordings/<frame_time>/snapshot.<format>")
-def get_snapshot_from_recording(camera_name: str, frame_time: str, format: str):
-    if camera_name not in current_app.frigate_config.cameras:
-        return make_response(
-            jsonify({"success": False, "message": "Camera not found"}),
-            404,
+@router.get("/media/camera/{camera_name}/recordings/{frame_time}/snapshot.{format}")
+def get_snapshot_from_recording(
+    request: Request,
+    camera_name: str,
+    frame_time: float,
+    format: str = Path(enum=["png", "jpg"]),
+    height: int = None,
+):
+    if camera_name not in request.app.frigate_config.cameras:
+        return JSONResponse(
+            content={"success": False, "message": "Camera not found"},
+            status_code=404,
         )
 
-    if format not in ["png", "jpg"]:
-        return make_response(
-            jsonify({"success": False, "message": "Invalid format"}),
-            400,
-        )
-
-    frame_time = float(frame_time)
     recording_query = (
         Recordings.select(
             Recordings.path,
@@ -213,46 +243,40 @@ def get_snapshot_from_recording(camera_name: str, frame_time: str, format: str):
     try:
         recording: Recordings = recording_query.get()
         time_in_segment = frame_time - recording.start_time
-
-        height = request.args.get("height", type=int)
         codec = "png" if format == "png" else "mjpeg"
-
         image_data = get_image_from_recording(
             recording.path, time_in_segment, codec, height
         )
 
         if not image_data:
-            return make_response(
-                jsonify(
+            return JSONResponse(
+                content=(
                     {
                         "success": False,
                         "message": f"Unable to parse frame at time {frame_time}",
                     }
                 ),
-                404,
+                status_code=404,
             )
-
-        response = make_response(image_data)
-        response.headers["Content-Type"] = f"image/{format}"
-        return response
+        return Response(image_data, headers={"Content-Type": f"image/{format}"})
     except DoesNotExist:
-        return make_response(
-            jsonify(
-                {
-                    "success": False,
-                    "message": "Recording not found at {}".format(frame_time),
-                }
-            ),
-            404,
+        return JSONResponse(
+            content={
+                "success": False,
+                "message": "Recording not found at {}".format(frame_time),
+            },
+            status_code=404,
         )
 
 
-@MediaBp.route("/<camera_name>/plus/<frame_time>", methods=("POST",))
-def submit_recording_snapshot_to_plus(camera_name: str, frame_time: str):
-    if camera_name not in current_app.frigate_config.cameras:
-        return make_response(
-            jsonify({"success": False, "message": "Camera not found"}),
-            404,
+@router.post("/media/camera/{camera_name}/plus/{frame_time}")
+def submit_recording_snapshot_to_plus(
+    request: Request, camera_name: str, frame_time: str
+):
+    if camera_name not in request.app.frigate_config.cameras:
+        return JSONResponse(
+            content={"success": False, "message": "Camera not found"},
+            status_code=404,
         )
 
     frame_time = float(frame_time)
@@ -275,56 +299,50 @@ def submit_recording_snapshot_to_plus(camera_name: str, frame_time: str):
     try:
         recording: Recordings = recording_query.get()
         time_in_segment = frame_time - recording.start_time
-        image_data = get_image_from_recording(recording.path, time_in_segment, "png")
+        image_data = get_image_from_recording(recording.path, time_in_segment)
 
         if not image_data:
-            return make_response(
-                jsonify(
-                    {
-                        "success": False,
-                        "message": f"Unable to parse frame at time {frame_time}",
-                    }
-                ),
-                404,
+            return JSONResponse(
+                content={
+                    "success": False,
+                    "message": f"Unable to parse frame at time {frame_time}",
+                },
+                status_code=404,
             )
 
         nd = cv2.imdecode(np.frombuffer(image_data, dtype=np.int8), cv2.IMREAD_COLOR)
-        current_app.plus_api.upload_image(nd, camera_name)
+        request.app.plus_api.upload_image(nd, camera_name)
 
-        return make_response(
-            jsonify(
-                {
-                    "success": True,
-                    "message": "Successfully submitted image.",
-                }
-            ),
-            200,
+        return JSONResponse(
+            content={
+                "success": True,
+                "message": "Successfully submitted image.",
+            },
+            status_code=200,
         )
     except DoesNotExist:
-        return make_response(
-            jsonify(
-                {
-                    "success": False,
-                    "message": "Recording not found at {}".format(frame_time),
-                }
-            ),
-            404,
+        return JSONResponse(
+            content={
+                "success": False,
+                "message": "Recording not found at {}".format(frame_time),
+            },
+            status_code=404,
         )
 
 
-@MediaBp.route("/recordings/storage", methods=["GET"])
-def get_recordings_storage_usage():
-    recording_stats = current_app.stats_emitter.get_latest_stats()["service"][
+@router.get("/media/recordings/storage")
+def get_recordings_storage_usage(request: Request):
+    recording_stats = request.app.stats_emitter.get_latest_stats()["service"][
         "storage"
     ][RECORD_DIR]
 
     if not recording_stats:
-        return jsonify({})
+        return JSONResponse({})
 
     total_mb = recording_stats["total"]
 
     camera_usages: dict[str, dict] = (
-        current_app.storage_maintainer.calculate_camera_usages()
+        request.app.storage_maintainer.calculate_camera_usages()
     )
 
     for camera_name in camera_usages.keys():
@@ -333,14 +351,13 @@ def get_recordings_storage_usage():
                 camera_usages.get(camera_name, {}).get("usage", 0) / total_mb
             ) * 100
 
-    return jsonify(camera_usages)
+    return JSONResponse(content=camera_usages)
 
 
-# return hourly summary for recordings of camera
-@MediaBp.route("/<camera_name>/recordings/summary")
-def recordings_summary(camera_name):
-    tz_name = request.args.get("timezone", default="utc", type=str)
-    hour_modifier, minute_modifier, seconds_offset = get_tz_modifiers(tz_name)
+@router.get("/media/camera/{camera_name}/recordings/summary")
+def recordings_summary(camera_name: str, timezone: str = "utc"):
+    """Returns hourly summary for recordings of given camera"""
+    hour_modifier, minute_modifier, seconds_offset = get_tz_modifiers(timezone)
     recording_groups = (
         Recordings.select(
             fn.strftime(
@@ -396,17 +413,16 @@ def recordings_summary(camera_name):
             days[day]["events"] += events_count
             days[day]["hours"].append(hour_data)
 
-    return jsonify(list(days.values()))
+    return JSONResponse(content=list(days.values()))
 
 
-# return hour of recordings data for camera
-@MediaBp.route("/<camera_name>/recordings")
-def recordings(camera_name):
-    after = request.args.get(
-        "after", type=float, default=(datetime.now() - timedelta(hours=1)).timestamp()
-    )
-    before = request.args.get("before", type=float, default=datetime.now().timestamp())
-
+@router.get("/media/camera/{camera_name}/recordings")
+def recordings(
+    camera_name: str,
+    after: float = (datetime.now() - timedelta(hours=1)).timestamp(),
+    before: float = datetime.now().timestamp(),
+):
+    """Return specific camera recordings between the given 'after'/'end' times. If not provided the last hour will be used"""
     recordings = (
         Recordings.select(
             Recordings.id,
@@ -427,14 +443,13 @@ def recordings(camera_name):
         .iterator()
     )
 
-    return jsonify(list(recordings))
+    return JSONResponse(content=list(recordings))
 
 
-@MediaBp.route("/<camera_name>/start/<int:start_ts>/end/<int:end_ts>/clip.mp4")
-@MediaBp.route("/<camera_name>/start/<float:start_ts>/end/<float:end_ts>/clip.mp4")
-def recording_clip(camera_name, start_ts, end_ts):
-    download = request.args.get("download", type=bool)
-
+@router.get("/media/camera/{camera_name}/start/{start_ts}/end/{end_ts}/clip.mp4")
+def recording_clip(
+    camera_name: str, start_ts: float, end_ts: float, download: bool = False
+):
     recordings = (
         Recordings.select(
             Recordings.path,
@@ -464,11 +479,12 @@ def recording_clip(camera_name, start_ts, end_ts):
     file_name = f"clip_{camera_name}_{start_ts}-{end_ts}.mp4"
 
     if len(file_name) > 1000:
-        return make_response(
-            jsonify(
-                {"success": False, "message": "Filename exceeded max length of 1000"}
-            ),
-            403,
+        return JSONResponse(
+            content={
+                "success": False,
+                "message": "Filename exceeded max length of 1000",
+            },
+            status_code=403,
         )
 
     file_name = secure_filename(file_name)
@@ -502,37 +518,40 @@ def recording_clip(camera_name, start_ts, end_ts):
 
         if p.returncode != 0:
             logger.error(p.stderr)
-            return make_response(
-                jsonify(
-                    {
-                        "success": False,
-                        "message": "Could not create clip from recordings",
-                    }
-                ),
-                500,
+            return JSONResponse(
+                content={
+                    "success": False,
+                    "message": "Could not create clip from recordings",
+                },
+                status_code=500,
             )
     else:
         logger.debug(
             f"Ignoring subsequent request for {path} as it already exists in the cache."
         )
 
-    response = make_response()
-    response.headers["Content-Description"] = "File Transfer"
-    response.headers["Cache-Control"] = "no-cache"
-    response.headers["Content-Type"] = "video/mp4"
+    headers = {
+        "Content-Description": "File Transfer",
+        "Cache-Control": "no-cache",
+        "Content-Type": "video/mp4",
+        "Content-Length": str(os.path.getsize(path)),
+        # nginx: https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_headers
+        "X-Accel-Redirect": f"/clips/cache/{file_name}",
+    }
+
     if download:
-        response.headers["Content-Disposition"] = "attachment; filename=%s" % file_name
-    response.headers["Content-Length"] = os.path.getsize(path)
-    response.headers["X-Accel-Redirect"] = (
-        f"/clips/cache/{file_name}"  # nginx: https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_headers
+        headers["Content-Disposition"] = "attachment; filename=%s" % file_name
+
+    return FileResponse(
+        path,
+        media_type="video/mp4",
+        filename=file_name,
+        headers=headers,
     )
 
-    return response
 
-
-@MediaBp.route("/vod/<camera_name>/start/<int:start_ts>/end/<int:end_ts>")
-@MediaBp.route("/vod/<camera_name>/start/<float:start_ts>/end/<float:end_ts>")
-def vod_ts(camera_name, start_ts, end_ts):
+@router.get("/vod/{camera_name}/start/{start_ts}/end/{end_ts}")
+def vod_ts(camera_name: str, start_ts: float, end_ts: float):
     recordings = (
         Recordings.select(Recordings.path, Recordings.duration, Recordings.end_time)
         .where(
@@ -574,19 +593,17 @@ def vod_ts(camera_name, start_ts, end_ts):
         logger.error(
             f"No recordings found for {camera_name} during the requested time range"
         )
-        return make_response(
-            jsonify(
-                {
-                    "success": False,
-                    "message": "No recordings found.",
-                }
-            ),
-            404,
+        return JSONResponse(
+            content={
+                "success": False,
+                "message": "No recordings found.",
+            },
+            status_code=404,
         )
 
     hour_ago = datetime.now() - timedelta(hours=1)
-    return jsonify(
-        {
+    return JSONResponse(
+        content={
             "cache": hour_ago.timestamp() > start_ts,
             "discontinuity": False,
             "consistentSequenceMediaInfo": True,
@@ -597,18 +614,19 @@ def vod_ts(camera_name, start_ts, end_ts):
     )
 
 
-@MediaBp.route("/vod/<year_month>/<day>/<hour>/<camera_name>")
-def vod_hour_no_timezone(year_month, day, hour, camera_name):
+@router.get("/vod/{year_month}/{day}/{hour}/{camera_name}")
+def vod_hour_no_timezone(year_month: str, day: int, hour: int, camera_name: str):
+    """VOD for specific hour. Uses the default timezone (UTC)."""
     return vod_hour(
         year_month, day, hour, camera_name, get_localzone_name().replace("/", ",")
     )
 
 
-@MediaBp.route("/vod/<year_month>/<day>/<hour>/<camera_name>/<tz_name>")
-def vod_hour(year_month, day, hour, camera_name, tz_name):
+@router.get("/vod/{year_month}/{day}/{hour}/{camera_name}/{tz_name}")
+def vod_hour(year_month: str, day: int, hour: int, camera_name: str, tz_name: str):
     parts = year_month.split("-")
     start_date = (
-        datetime(int(parts[0]), int(parts[1]), int(day), int(hour), tzinfo=timezone.utc)
+        datetime(int(parts[0]), int(parts[1]), day, hour, tzinfo=timezone.utc)
         - datetime.now(pytz.timezone(tz_name.replace(",", "/"))).utcoffset()
     )
     end_date = start_date + timedelta(hours=1) - timedelta(milliseconds=1)
@@ -618,32 +636,28 @@ def vod_hour(year_month, day, hour, camera_name, tz_name):
     return vod_ts(camera_name, start_ts, end_ts)
 
 
-@MediaBp.route("/vod/event/<id>")
-def vod_event(id):
+@router.get("/vod/event/{event_id}")
+def vod_event(event_id: str):
     try:
-        event: Event = Event.get(Event.id == id)
+        event: Event = Event.get(Event.id == event_id)
     except DoesNotExist:
-        logger.error(f"Event not found: {id}")
-        return make_response(
-            jsonify(
-                {
-                    "success": False,
-                    "message": "Event not found.",
-                }
-            ),
-            404,
+        logger.error(f"Event not found: {event_id}")
+        return JSONResponse(
+            content={
+                "success": False,
+                "message": "Event not found.",
+            },
+            status_code=404,
         )
 
     if not event.has_clip:
-        logger.error(f"Event does not have recordings: {id}")
-        return make_response(
-            jsonify(
-                {
-                    "success": False,
-                    "message": "Recordings not available.",
-                }
-            ),
-            404,
+        logger.error(f"Event does not have recordings: {event_id}")
+        return JSONResponse(
+            content={
+                "success": False,
+                "message": "Recordings not available.",
+            },
+            status_code=404,
         )
 
     clip_path = os.path.join(CLIPS_DIR, f"{event.camera}-{event.id}.mp4")
@@ -660,12 +674,12 @@ def vod_event(id):
             and len(vod_response) == 2
             and vod_response[1] == 404
         ):
-            Event.update(has_clip=False).where(Event.id == id).execute()
+            Event.update(has_clip=False).where(Event.id == event_id).execute()
         return vod_response
 
     duration = int((event.end_time - event.start_time) * 1000)
-    return jsonify(
-        {
+    return JSONResponse(
+        content={
             "cache": True,
             "discontinuity": False,
             "durations": [duration],
@@ -674,8 +688,9 @@ def vod_event(id):
     )
 
 
-@MediaBp.route("/<camera_name>/<label>/snapshot.jpg")
-def label_snapshot(camera_name, label):
+@router.get("/media/camera/{camera_name}/label/{label}/snapshot.jpg")
+def label_snapshot(request: Request, camera_name: str, label: str):
+    """Returns the snapshot image from the latest event for the given camera and label combo"""
     label = unquote(label)
     if label == "any":
         event_query = (
@@ -695,40 +710,42 @@ def label_snapshot(camera_name, label):
 
     try:
         event = event_query.get()
-        return event_snapshot(event.id)
+        return event_snapshot(request, event.id)
     except DoesNotExist:
         frame = np.zeros((720, 1280, 3), np.uint8)
         ret, jpg = cv2.imencode(".jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 70])
 
-        response = make_response(jpg.tobytes())
-        response.headers["Content-Type"] = "image/jpeg"
-        return response
+        return StreamingResponse(
+            io.BytesIO(jpg.tobytes()),
+            media_type="image/jpeg",
+        )
 
 
-@MediaBp.route("/<camera_name>/<label>/best.jpg")
-@MediaBp.route("/<camera_name>/<label>/thumbnail.jpg")
-def label_thumbnail(camera_name, label):
+@router.get("/media/camera/{camera_name}/label/{label}/best.jpg")
+@router.get("/media/camera/{camera_name}/label/{label}/thumbnail.jpg")
+def label_thumbnail(request: Request, camera_name: str, label: str):
     label = unquote(label)
     event_query = Event.select(fn.MAX(Event.id)).where(Event.camera == camera_name)
     if label != "any":
         event_query = event_query.where(Event.label == label)
 
     try:
-        event = event_query.scalar()
+        event_id = event_query.scalar()
 
-        return event_thumbnail(event, 60)
+        return event_thumbnail(request, event_id, 60)
     except DoesNotExist:
         frame = np.zeros((175, 175, 3), np.uint8)
         ret, jpg = cv2.imencode(".jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 70])
 
-        response = make_response(jpg.tobytes())
-        response.headers["Content-Type"] = "image/jpeg"
-        response.headers["Cache-Control"] = "no-store"
-        return response
+        return StreamingResponse(
+            io.BytesIO(jpg.tobytes()),
+            media_type="image/jpeg",
+            headers={"Cache-Control": "no-store"},
+        )
 
 
-@MediaBp.route("/<camera_name>/<label>/clip.mp4")
-def label_clip(camera_name, label):
+@router.get("/media/camera/{camera_name}/label/{label}/clip.mp4")
+def label_clip(camera_name: str, label: str):
     label = unquote(label)
     event_query = Event.select(fn.MAX(Event.id)).where(
         Event.camera == camera_name, Event.has_clip == True
@@ -739,32 +756,32 @@ def label_clip(camera_name, label):
     try:
         event = event_query.get()
 
-        return event_clip(event)
+        return event_clip(event.id)
     except DoesNotExist:
-        return make_response(
-            jsonify({"success": False, "message": "Event not found"}), 404
+        return JSONResponse(
+            content={"success": False, "message": "Event not found"}, status_code=404
         )
 
 
-@MediaBp.route("/<camera_name>/grid.jpg")
-def grid_snapshot(camera_name):
-    request.args.get("type", default="region")
-
-    if camera_name in current_app.frigate_config.cameras:
-        detect = current_app.frigate_config.cameras[camera_name].detect
-        frame = current_app.detected_frames_processor.get_current_frame(camera_name, {})
+@router.get("/media/camera/{camera_name}/grid.jpg")
+def grid_snapshot(
+    request: Request, camera_name: str, color: str = "green", font_scale: float = 0.5
+):
+    if camera_name in request.app.frigate_config.cameras:
+        detect = request.app.frigate_config.cameras[camera_name].detect
+        frame = request.app.detected_frames_processor.get_current_frame(camera_name, {})
         retry_interval = float(
-            current_app.frigate_config.cameras.get(camera_name).ffmpeg.retry_interval
+            request.app.frigate_config.cameras.get(camera_name).ffmpeg.retry_interval
             or 10
         )
 
         if frame is None or datetime.now().timestamp() > (
-            current_app.detected_frames_processor.get_current_frame_time(camera_name)
+            request.app.detected_frames_processor.get_current_frame_time(camera_name)
             + retry_interval
         ):
-            return make_response(
-                jsonify({"success": False, "message": "Unable to get valid frame"}),
-                500,
+            return JSONResponse(
+                content={"success": False, "message": "Unable to get valid frame"},
+                status_code=500,
             )
 
         try:
@@ -775,13 +792,12 @@ def grid_snapshot(camera_name):
                 .grid
             )
         except DoesNotExist:
-            return make_response(
-                jsonify({"success": False, "message": "Unable to get region grid"}),
-                500,
+            return JSONResponse(
+                content={"success": False, "message": "Unable to get region grid"},
+                status_code=500,
             )
 
-        color_arg = request.args.get("color", default="", type=str).lower()
-        draw_font_scale = request.args.get("font_scale", default=0.5, type=float)
+        color_arg = color.lower()
 
         if color_arg == "red":
             draw_color = (0, 0, 255)
@@ -792,7 +808,7 @@ def grid_snapshot(camera_name):
         elif color_arg == "white":
             draw_color = (255, 255, 255)
         else:
-            draw_color = (0, 255, 0)
+            draw_color = (0, 255, 0)  # green
 
         grid_size = len(grid)
         grid_coef = 1.0 / grid_size
@@ -825,7 +841,7 @@ def grid_snapshot(camera_name):
                         int((y * grid_coef + 0.02) * height),
                     ),
                     cv2.FONT_HERSHEY_SIMPLEX,
-                    fontScale=draw_font_scale,
+                    fontScale=font_scale,
                     color=draw_color,
                     thickness=2,
                 )
@@ -837,7 +853,7 @@ def grid_snapshot(camera_name):
                         int((y * grid_coef + 0.05) * height),
                     ),
                     cv2.FONT_HERSHEY_SIMPLEX,
-                    fontScale=draw_font_scale,
+                    fontScale=font_scale,
                     color=draw_color,
                     thickness=2,
                 )
@@ -849,63 +865,64 @@ def grid_snapshot(camera_name):
                         int((y * grid_coef + 0.08) * height),
                     ),
                     cv2.FONT_HERSHEY_SIMPLEX,
-                    fontScale=draw_font_scale,
+                    fontScale=font_scale,
                     color=draw_color,
                     thickness=2,
                 )
 
         ret, jpg = cv2.imencode(".jpg", frame, [int(cv2.IMWRITE_JPEG_QUALITY), 70])
-        response = make_response(jpg.tobytes())
-        response.headers["Content-Type"] = "image/jpeg"
-        response.headers["Cache-Control"] = "no-store"
-        return response
+
+        return StreamingResponse(
+            io.BytesIO(jpg.tobytes()),
+            media_type="image/jpeg",
+            headers={"Cache-Control": "no-store"},
+        )
     else:
-        return make_response(
-            jsonify({"success": False, "message": "Camera not found"}),
-            404,
+        return JSONResponse(
+            content={"success": False, "message": "Camera not found"},
+            status_code=404,
         )
 
 
-@MediaBp.route("/events/<id>/snapshot-clean.png")
-def event_snapshot_clean(id):
-    download = request.args.get("download", type=bool)
+@router.get("/media/events/{event_id}/snapshot-clean.png")
+def event_snapshot_clean(request: Request, event_id: str, download: bool = False):
     png_bytes = None
     try:
-        event = Event.get(Event.id == id)
-        snapshot_config = current_app.frigate_config.cameras[event.camera].snapshots
+        event = Event.get(Event.id == event_id)
+        snapshot_config = request.app.frigate_config.cameras[event.camera].snapshots
         if not (snapshot_config.enabled and event.has_snapshot):
-            return make_response(
-                jsonify(
-                    {
-                        "success": False,
-                        "message": "Snapshots and clean_copy must be enabled in the config",
-                    }
-                ),
-                404,
+            return JSONResponse(
+                content={
+                    "success": False,
+                    "message": "Snapshots and clean_copy must be enabled in the config",
+                },
+                status_code=404,
             )
         if event.end_time is None:
             # see if the object is currently being tracked
             try:
                 camera_states = (
-                    current_app.detected_frames_processor.camera_states.values()
+                    request.app.detected_frames_processor.camera_states.values()
                 )
                 for camera_state in camera_states:
-                    if id in camera_state.tracked_objects:
-                        tracked_obj = camera_state.tracked_objects.get(id)
+                    if event_id in camera_state.tracked_objects:
+                        tracked_obj = camera_state.tracked_objects.get(event_id)
                         if tracked_obj is not None:
                             png_bytes = tracked_obj.get_clean_png()
                             break
             except Exception:
-                return make_response(
-                    jsonify({"success": False, "message": "Event not found"}), 404
+                return JSONResponse(
+                    content={"success": False, "message": "Event not found"},
+                    status_code=404,
                 )
         elif not event.has_snapshot:
-            return make_response(
-                jsonify({"success": False, "message": "Snapshot not available"}), 404
+            return JSONResponse(
+                content={"success": False, "message": "Snapshot not available"},
+                status_code=404,
             )
     except DoesNotExist:
-        return make_response(
-            jsonify({"success": False, "message": "Event not found"}), 404
+        return JSONResponse(
+            content={"success": False, "message": "Event not found"}, status_code=404
         )
     if png_bytes is None:
         try:
@@ -913,11 +930,12 @@ def event_snapshot_clean(id):
                 CLIPS_DIR, f"{event.camera}-{event.id}-clean.png"
             )
             if not os.path.exists(clean_snapshot_path):
-                return make_response(
-                    jsonify(
-                        {"success": False, "message": "Clean snapshot not available"}
-                    ),
-                    404,
+                return JSONResponse(
+                    content={
+                        "success": False,
+                        "message": "Clean snapshot not available",
+                    },
+                    status_code=404,
                 )
             with open(
                 os.path.join(CLIPS_DIR, f"{event.camera}-{event.id}-clean.png"), "rb"
@@ -925,33 +943,51 @@ def event_snapshot_clean(id):
                 png_bytes = image_file.read()
         except Exception:
             logger.error(f"Unable to load clean png for event: {event.id}")
-            return make_response(
-                jsonify(
-                    {"success": False, "message": "Unable to load clean png for event"}
-                ),
-                400,
+            return JSONResponse(
+                content={
+                    "success": False,
+                    "message": "Unable to load clean png for event",
+                },
+                status_code=400,
             )
-    response = make_response(png_bytes)
-    response.headers["Content-Type"] = "image/png"
-    response.headers["Cache-Control"] = "private, max-age=31536000"
+
+    headers = {
+        "Content-Type": "image/png",
+        "Cache-Control": "private, max-age=31536000",
+    }
+
     if download:
-        response.headers["Content-Disposition"] = (
-            f"attachment; filename=snapshot-{id}-clean.png"
+        headers["Content-Disposition"] = (
+            f"attachment; filename=snapshot-{event_id}-clean.png"
         )
-    return response
+
+    return StreamingResponse(
+        io.BytesIO(png_bytes),
+        media_type="image/png",
+        headers=headers,
+    )
 
 
-@MediaBp.route("/events/<id>/snapshot.jpg")
-def event_snapshot(id):
-    download = request.args.get("download", type=bool)
+@router.get("/media/events/{event_id}/snapshot.jpg")
+def event_snapshot(
+    request: Request,
+    event_id: str,
+    download: bool = False,
+    timestamp: Optional[int] = None,
+    bbox: Optional[int] = None,
+    crop: Optional[int] = None,
+    height: Optional[int] = None,
+    quality: Optional[int] = 70,
+):
     event_complete = False
     jpg_bytes = None
     try:
-        event = Event.get(Event.id == id, Event.end_time != None)
+        event = Event.get(Event.id == event_id, Event.end_time != None)
         event_complete = True
         if not event.has_snapshot:
-            return make_response(
-                jsonify({"success": False, "message": "Snapshot not available"}), 404
+            return JSONResponse(
+                content={"success": False, "message": "Snapshot not available"},
+                status_code=404,
             )
         # read snapshot from disk
         with open(
@@ -961,59 +997,60 @@ def event_snapshot(id):
     except DoesNotExist:
         # see if the object is currently being tracked
         try:
-            camera_states = current_app.detected_frames_processor.camera_states.values()
+            camera_states = request.app.detected_frames_processor.camera_states.values()
             for camera_state in camera_states:
-                if id in camera_state.tracked_objects:
-                    tracked_obj = camera_state.tracked_objects.get(id)
+                if event_id in camera_state.tracked_objects:
+                    tracked_obj = camera_state.tracked_objects.get(event_id)
                     if tracked_obj is not None:
                         jpg_bytes = tracked_obj.get_jpg_bytes(
-                            timestamp=request.args.get("timestamp", type=int),
-                            bounding_box=request.args.get("bbox", type=int),
-                            crop=request.args.get("crop", type=int),
-                            height=request.args.get("h", type=int),
-                            quality=request.args.get("quality", default=70, type=int),
+                            timestamp=timestamp,
+                            bounding_box=bbox,
+                            crop=crop,
+                            height=height,
+                            quality=quality,
                         )
         except Exception:
-            return make_response(
-                jsonify({"success": False, "message": "Event not found"}), 404
+            return JSONResponse(
+                content={"success": False, "message": "Event not found"},
+                status_code=404,
             )
     except Exception:
-        return make_response(
-            jsonify({"success": False, "message": "Event not found"}), 404
+        return JSONResponse(
+            content={"success": False, "message": "Event not found"}, status_code=404
         )
 
     if jpg_bytes is None:
-        return make_response(
-            jsonify({"success": False, "message": "Event not found"}), 404
+        return JSONResponse(
+            content={"success": False, "message": "Event not found"}, status_code=404
         )
 
-    response = make_response(jpg_bytes)
-    response.headers["Content-Type"] = "image/jpeg"
-    if event_complete:
-        response.headers["Cache-Control"] = "private, max-age=31536000"
-    else:
-        response.headers["Cache-Control"] = "no-store"
+    headers = {
+        "Content-Type": "image/jpeg",
+        "Cache-Control": "private, max-age=31536000" if event_complete else "no-store",
+    }
+
     if download:
-        response.headers["Content-Disposition"] = (
-            f"attachment; filename=snapshot-{id}.jpg"
-        )
-    return response
+        headers["Content-Disposition"] = f"attachment; filename=snapshot-{event_id}.jpg"
+
+    return StreamingResponse(
+        io.BytesIO(jpg_bytes),
+        media_type="image/jpeg",
+        headers=headers,
+    )
 
 
-@MediaBp.route("/events/<id>/clip.mp4")
-def event_clip(id):
-    download = request.args.get("download", type=bool)
-
+@router.get("/media/events/{event_id}/clip.mp4")
+def event_clip(event_id: str, download: bool = False):
     try:
-        event: Event = Event.get(Event.id == id)
+        event: Event = Event.get(Event.id == event_id)
     except DoesNotExist:
-        return make_response(
-            jsonify({"success": False, "message": "Event not found"}), 404
+        return JSONResponse(
+            content={"success": False, "message": "Event not found"}, status_code=404
         )
 
     if not event.has_clip:
-        return make_response(
-            jsonify({"success": False, "message": "Clip not available"}), 404
+        return JSONResponse(
+            content={"success": False, "message": "Clip not available"}, status_code=404
         )
 
     file_name = f"{event.camera}-{event.id}.mp4"
@@ -1023,49 +1060,63 @@ def event_clip(id):
         end_ts = (
             datetime.now().timestamp() if event.end_time is None else event.end_time
         )
-        return recording_clip(event.camera, event.start_time, end_ts)
+        return recording_clip(event.camera, event.start_time, end_ts, download)
+
+    headers = {
+        "Content-Description": "File Transfer",
+        "Cache-Control": "no-cache",
+        "Content-Type": "video/mp4",
+        "Content-Length": str(os.path.getsize(clip_path)),
+        # nginx: https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_headers
+        "X-Accel-Redirect": f"/clips/{file_name}",
+    }
 
-    response = make_response()
-    response.headers["Content-Description"] = "File Transfer"
-    response.headers["Cache-Control"] = "no-cache"
-    response.headers["Content-Type"] = "video/mp4"
     if download:
-        response.headers["Content-Disposition"] = "attachment; filename=%s" % file_name
-    response.headers["Content-Length"] = os.path.getsize(clip_path)
-    response.headers["X-Accel-Redirect"] = (
-        f"/clips/{file_name}"  # nginx: https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_headers
+        headers["Content-Disposition"] = "attachment; filename=%s" % file_name
+
+    return FileResponse(
+        clip_path,
+        media_type="video/mp4",
+        filename=file_name,
+        headers=headers,
     )
 
-    return response
 
-
-@MediaBp.route("/events/<id>/thumbnail.jpg")
-def event_thumbnail(id, max_cache_age=2592000):
-    format = request.args.get("format", "ios")
+@router.get("/media/events/{event_id}/thumbnail.jpg")
+def event_thumbnail(
+    request: Request,
+    event_id: str,
+    max_cache_age: int = Query(
+        2592000, description="Max cache age in seconds. Default 30 days in seconds."
+    ),
+    format: str = Query(default="ios", enum=["ios", "android"]),
+):
     thumbnail_bytes = None
     event_complete = False
     try:
-        event = Event.get(Event.id == id)
+        event = Event.get(Event.id == event_id)
         if event.end_time is not None:
             event_complete = True
         thumbnail_bytes = base64.b64decode(event.thumbnail)
     except DoesNotExist:
         # see if the object is currently being tracked
         try:
-            camera_states = current_app.detected_frames_processor.camera_states.values()
+            camera_states = request.app.detected_frames_processor.camera_states.values()
             for camera_state in camera_states:
-                if id in camera_state.tracked_objects:
-                    tracked_obj = camera_state.tracked_objects.get(id)
+                if event_id in camera_state.tracked_objects:
+                    tracked_obj = camera_state.tracked_objects.get(event_id)
                     if tracked_obj is not None:
                         thumbnail_bytes = tracked_obj.get_thumbnail()
         except Exception:
-            return make_response(
-                jsonify({"success": False, "message": "Event not found"}), 404
+            return JSONResponse(
+                content={"success": False, "message": "Event not found"},
+                status_code=404,
             )
 
     if thumbnail_bytes is None:
-        return make_response(
-            jsonify({"success": False, "message": "Event not found"}), 404
+        return JSONResponse(
+            content={"success": False, "message": "Event not found"},
+            status_code=404,
         )
 
     # android notifications prefer a 2:1 ratio
@@ -1084,22 +1135,25 @@ def event_thumbnail(id, max_cache_age=2592000):
         ret, jpg = cv2.imencode(".jpg", thumbnail, [int(cv2.IMWRITE_JPEG_QUALITY), 70])
         thumbnail_bytes = jpg.tobytes()
 
-    response = make_response(thumbnail_bytes)
-    response.headers["Content-Type"] = "image/jpeg"
-    if event_complete:
-        response.headers["Cache-Control"] = f"private, max-age={max_cache_age}"
-    else:
-        response.headers["Cache-Control"] = "no-store"
-    return response
+    return StreamingResponse(
+        io.BytesIO(thumbnail_bytes),
+        media_type="image/jpeg",
+        headers={
+            "Cache-Control": f"private, max-age={max_cache_age}"
+            if event_complete
+            else "no-store",
+            "Content-Type": "image/jpeg",
+        },
+    )
 
 
-@MediaBp.route("/events/<id>/preview.gif")
-def event_preview(id: str):
+@router.get("/media/events/{event_id}/preview.gif")
+def event_preview(event_id: str):
     try:
-        event: Event = Event.get(Event.id == id)
+        event: Event = Event.get(Event.id == event_id)
     except DoesNotExist:
-        return make_response(
-            jsonify({"success": False, "message": "Event not found"}), 404
+        return JSONResponse(
+            content={"success": False, "message": "Event not found"}, status_code=404
         )
 
     start_ts = event.start_time
@@ -1109,9 +1163,15 @@ def event_preview(id: str):
     return preview_gif(event.camera, start_ts, end_ts)
 
 
-@MediaBp.route("/<camera_name>/start/<int:start_ts>/end/<int:end_ts>/preview.gif")
-@MediaBp.route("/<camera_name>/start/<float:start_ts>/end/<float:end_ts>/preview.gif")
-def preview_gif(camera_name: str, start_ts, end_ts, max_cache_age=2592000):
+@router.get("/media/camera/{camera_name}/start/{start_ts}/end/{end_ts}/preview.gif")
+def preview_gif(
+    camera_name: str,
+    start_ts: float,
+    end_ts: float,
+    max_cache_age: int = Query(
+        2592000, description="Max cache age in seconds. Default 30 days in seconds."
+    ),
+):
     if datetime.fromtimestamp(start_ts) < datetime.now().replace(minute=0, second=0):
         # has preview mp4
         preview: Previews = (
@@ -1133,8 +1193,9 @@ def preview_gif(camera_name: str, start_ts, end_ts, max_cache_age=2592000):
         )
 
         if not preview:
-            return make_response(
-                jsonify({"success": False, "message": "Preview not found"}), 404
+            return JSONResponse(
+                content={"success": False, "message": "Preview not found"},
+                status_code=404,
             )
 
         diff = start_ts - preview.start_time
@@ -1171,9 +1232,9 @@ def preview_gif(camera_name: str, start_ts, end_ts, max_cache_age=2592000):
 
         if process.returncode != 0:
             logger.error(process.stderr)
-            return make_response(
-                jsonify({"success": False, "message": "Unable to create preview gif"}),
-                500,
+            return JSONResponse(
+                content={"success": False, "message": "Unable to create preview gif"},
+                status_code=500,
             )
 
         gif_bytes = process.stdout
@@ -1199,8 +1260,9 @@ def preview_gif(camera_name: str, start_ts, end_ts, max_cache_age=2592000):
             selected_previews.append("duration 0.12")
 
         if not selected_previews:
-            return make_response(
-                jsonify({"success": False, "message": "Preview not found"}), 404
+            return JSONResponse(
+                content={"success": False, "message": "Preview not found"},
+                status_code=404,
             )
 
         last_file = selected_previews[-2]
@@ -1237,33 +1299,43 @@ def preview_gif(camera_name: str, start_ts, end_ts, max_cache_age=2592000):
 
         if process.returncode != 0:
             logger.error(process.stderr)
-            return make_response(
-                jsonify({"success": False, "message": "Unable to create preview gif"}),
-                500,
+            return JSONResponse(
+                content={"success": False, "message": "Unable to create preview gif"},
+                status_code=500,
             )
 
         gif_bytes = process.stdout
 
-    response = make_response(gif_bytes)
-    response.headers["Content-Type"] = "image/gif"
-    response.headers["Cache-Control"] = f"private, max-age={max_cache_age}"
-    return response
+    return StreamingResponse(
+        io.BytesIO(gif_bytes),
+        media_type="image/gif",
+        headers={
+            "Cache-Control": f"private, max-age={max_cache_age}",
+            "Content-Type": "image/gif",
+        },
+    )
 
 
-@MediaBp.route("/<camera_name>/start/<int:start_ts>/end/<int:end_ts>/preview.mp4")
-@MediaBp.route("/<camera_name>/start/<float:start_ts>/end/<float:end_ts>/preview.mp4")
-def preview_mp4(camera_name: str, start_ts, end_ts, max_cache_age=604800):
+@router.get("/media/camera/{camera_name}/start/{start_ts}/end/{end_ts}/preview.mp4")
+def preview_mp4(
+    camera_name: str,
+    start_ts: float,
+    end_ts: float,
+    max_cache_age: int = Query(
+        604800, description="Max cache age in seconds. Default 7 days in seconds."
+    ),
+):
     file_name = f"preview_{camera_name}_{start_ts}-{end_ts}.mp4"
 
     if len(file_name) > 1000:
-        return make_response(
-            jsonify(
+        return JSONResponse(
+            content=(
                 {
                     "success": False,
                     "message": "Filename exceeded max length of 1000 characters.",
                 }
             ),
-            403,
+            status_code=403,
         )
 
     file_name = secure_filename(file_name)
@@ -1293,8 +1365,9 @@ def preview_mp4(camera_name: str, start_ts, end_ts, max_cache_age=604800):
             preview = None
 
         if not preview:
-            return make_response(
-                jsonify({"success": False, "message": "Preview not found"}), 404
+            return JSONResponse(
+                content={"success": False, "message": "Preview not found"},
+                status_code=404,
             )
 
         diff = start_ts - preview.start_time
@@ -1330,9 +1403,9 @@ def preview_mp4(camera_name: str, start_ts, end_ts, max_cache_age=604800):
 
         if process.returncode != 0:
             logger.error(process.stderr)
-            return make_response(
-                jsonify({"success": False, "message": "Unable to create preview gif"}),
-                500,
+            return JSONResponse(
+                content={"success": False, "message": "Unable to create preview gif"},
+                status_code=500,
             )
 
     else:
@@ -1357,8 +1430,9 @@ def preview_mp4(camera_name: str, start_ts, end_ts, max_cache_age=604800):
             selected_previews.append("duration 0.12")
 
         if not selected_previews:
-            return make_response(
-                jsonify({"success": False, "message": "Preview not found"}), 404
+            return JSONResponse(
+                content={"success": False, "message": "Preview not found"},
+                status_code=404,
             )
 
         last_file = selected_previews[-2]
@@ -1393,31 +1467,39 @@ def preview_mp4(camera_name: str, start_ts, end_ts, max_cache_age=604800):
 
         if process.returncode != 0:
             logger.error(process.stderr)
-            return make_response(
-                jsonify({"success": False, "message": "Unable to create preview gif"}),
-                500,
+            return JSONResponse(
+                content={"success": False, "message": "Unable to create preview gif"},
+                status_code=500,
             )
 
-    response = make_response()
-    response.headers["Content-Description"] = "File Transfer"
-    response.headers["Cache-Control"] = f"private, max-age={max_cache_age}"
-    response.headers["Content-Type"] = "video/mp4"
-    response.headers["Content-Length"] = os.path.getsize(path)
-    response.headers["X-Accel-Redirect"] = (
-        f"/cache/{file_name}"  # nginx: https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_headers
+    headers = {
+        "Content-Description": "File Transfer",
+        "Cache-Control": f"private, max-age={max_cache_age}",
+        "Content-Type": "video/mp4",
+        "Content-Length": str(os.path.getsize(path)),
+        # nginx: https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_headers
+        "X-Accel-Redirect": f"/cache/{file_name}",
+    }
+
+    return FileResponse(
+        path,
+        media_type="video/mp4",
+        filename=file_name,
+        headers=headers,
     )
-    return response
 
 
-@MediaBp.route("/review/<id>/preview")
-def review_preview(id: str):
-    format = request.args.get("format", default="gif")
-
+@router.get("/media/review/{event_id}/preview")
+def review_preview(
+    event_id: str,
+    format: str = Query(default="gif", enum=["gif", "mp4"]),
+):
     try:
-        review: ReviewSegment = ReviewSegment.get(ReviewSegment.id == id)
+        review: ReviewSegment = ReviewSegment.get(ReviewSegment.id == event_id)
     except DoesNotExist:
-        return make_response(
-            jsonify({"success": False, "message": "Review segment not found"}), 404
+        return JSONResponse(
+            content=({"success": False, "message": "Review segment not found"}),
+            status_code=404,
         )
 
     padding = 8
@@ -1432,16 +1514,16 @@ def review_preview(id: str):
         return preview_mp4(review.camera, start_ts, end_ts)
 
 
-@MediaBp.route("/preview/<file_name>/thumbnail.jpg")
-@MediaBp.route("/preview/<file_name>/thumbnail.webp")
+@router.get("/media/preview/{file_name}/thumbnail.jpg")
+@router.get("/media/preview/{file_name}/thumbnail.webp")
 def preview_thumbnail(file_name: str):
     """Get a thumbnail from the cached preview frames."""
     if len(file_name) > 1000:
-        return make_response(
-            jsonify(
+        return JSONResponse(
+            content=(
                 {"success": False, "message": "Filename exceeded max length of 1000"}
             ),
-            403,
+            status_code=403,
         )
 
     safe_file_name_current = secure_filename(file_name)
@@ -1453,11 +1535,17 @@ def preview_thumbnail(file_name: str):
         ) as image_file:
             jpg_bytes = image_file.read()
     except FileNotFoundError:
-        return make_response(
-            jsonify({"success": False, "message": "Image file not found"}), 404
+        return JSONResponse(
+            content=({"success": False, "message": "Image file not found"}),
+            status_code=404,
         )
 
-    response = make_response(jpg_bytes)
-    response.headers["Content-Type"] = "image/webp"
-    response.headers["Cache-Control"] = "private, max-age=31536000"
-    return response
+    return StreamingResponse(
+        io.BytesIO(jpg_bytes),
+        # FIXME: Shouldn't it be either jpg or webp depending on the endpoint?
+        media_type="image/webp",
+        headers={
+            "Content-Type": "image/webp",
+            "Cache-Control": "private, max-age=31536000",
+        },
+    )
diff --git a/frigate/test/test_http.py b/frigate/test/test_http.py
index 936dc80e5..c7785f530 100644
--- a/frigate/test/test_http.py
+++ b/frigate/test/test_http.py
@@ -5,12 +5,14 @@ import os
 import unittest
 from unittest.mock import Mock
 
+from fastapi.testclient import TestClient
 from peewee_migrate import Router
 from playhouse.shortcuts import model_to_dict
 from playhouse.sqlite_ext import SqliteExtDatabase
 from playhouse.sqliteq import SqliteQueueDatabase
 
 from frigate.api.app import create_app
+from frigate.api.fastapi_app import create_fastapi_app
 from frigate.config import FrigateConfig
 from frigate.models import Event, Recordings
 from frigate.plus import PlusApi
@@ -362,24 +364,23 @@ class TestHttp(unittest.TestCase):
             assert config["cameras"]["front_door"]
 
     def test_recordings(self):
-        app = create_app(
+        app_fastapi = create_fastapi_app(
             FrigateConfig(**self.minimal_config).runtime_config(),
-            self.db,
-            None,
-            None,
             None,
             None,
             None,
             PlusApi(),
             None,
         )
+        client = TestClient(app_fastapi)
         id = "123456.random"
 
-        with app.test_client() as client:
-            _insert_mock_recording(id)
-            recording = client.get("/front_door/recordings").json
-            assert recording
-            assert recording[0]["id"] == id
+        _insert_mock_recording(id)
+        response = client.get("/media/camera/front_door/recordings")
+        assert response.status_code == 200
+        recording = response.json()
+        assert recording
+        assert recording[0]["id"] == id
 
     def test_stats(self):
         stats = Mock(spec=StatsEmitter)
diff --git a/web/src/components/camera/CameraImage.tsx b/web/src/components/camera/CameraImage.tsx
index 9f25f69a3..555f63234 100644
--- a/web/src/components/camera/CameraImage.tsx
+++ b/web/src/components/camera/CameraImage.tsx
@@ -54,7 +54,7 @@ export default function CameraImage({
       return;
     }
 
-    const newSrc = `${apiHost}api/${name}/latest.webp?h=${requestHeight}${
+    const newSrc = `${apiHost}api/media/camera/${name}/frame/latest?extension=webp&?height=${requestHeight}${
       searchParams ? `&${searchParams}` : ""
     }`;
 
diff --git a/web/src/components/camera/ResizingCameraImage.tsx b/web/src/components/camera/ResizingCameraImage.tsx
index f082c81c4..69ce64690 100644
--- a/web/src/components/camera/ResizingCameraImage.tsx
+++ b/web/src/components/camera/ResizingCameraImage.tsx
@@ -89,7 +89,7 @@ export default function CameraImage({
     if (!config || scaledHeight === 0 || !canvasRef.current) {
       return;
     }
-    img.src = `${apiHost}api/${name}/latest.webp?h=${scaledHeight}${
+    img.src = `${apiHost}api/media/camera/${name}/frame/latest?extension=webp&height=${scaledHeight}${
       searchParams ? `&${searchParams}` : ""
     }`;
   }, [apiHost, canvasRef, name, img, searchParams, scaledHeight, config]);
diff --git a/web/src/components/card/AnimatedEventCard.tsx b/web/src/components/card/AnimatedEventCard.tsx
index f18573542..c05175e4a 100644
--- a/web/src/components/card/AnimatedEventCard.tsx
+++ b/web/src/components/card/AnimatedEventCard.tsx
@@ -173,7 +173,7 @@ export function AnimatedEventCard({
                       }}
                     >
                       <source
-                        src={`${baseUrl}api/review/${event.id}/preview?format=mp4`}
+                        src={`${baseUrl}api/media/review/${event.id}/preview?format=mp4`}
                         type="video/mp4"
                       />
                     </video>
diff --git a/web/src/components/overlay/detail/ObjectLifecycle.tsx b/web/src/components/overlay/detail/ObjectLifecycle.tsx
index 4aef59fb3..e1008882a 100644
--- a/web/src/components/overlay/detail/ObjectLifecycle.tsx
+++ b/web/src/components/overlay/detail/ObjectLifecycle.tsx
@@ -160,13 +160,13 @@ export default function ObjectLifecycle({
   // image
 
   const [src, setSrc] = useState(
-    `${apiHost}api/${event.camera}/recordings/${event.start_time + annotationOffset / 1000}/snapshot.jpg?height=500`,
+    `${apiHost}api/media/camera/${event.camera}/recordings/${event.start_time + annotationOffset / 1000}/snapshot.jpg?height=500`,
   );
   const [hasError, setHasError] = useState(false);
 
   useEffect(() => {
     if (timeIndex) {
-      const newSrc = `${apiHost}api/${event.camera}/recordings/${timeIndex + annotationOffset / 1000}/snapshot.jpg?height=500`;
+      const newSrc = `${apiHost}api/media/camera/${event.camera}/recordings/${timeIndex + annotationOffset / 1000}/snapshot.jpg?height=500`;
       setSrc(newSrc);
     }
     setImgLoaded(false);
diff --git a/web/src/components/overlay/detail/ReviewDetailDialog.tsx b/web/src/components/overlay/detail/ReviewDetailDialog.tsx
index 1742c1fa2..62ab37131 100644
--- a/web/src/components/overlay/detail/ReviewDetailDialog.tsx
+++ b/web/src/components/overlay/detail/ReviewDetailDialog.tsx
@@ -248,8 +248,8 @@ function EventItem({
           draggable={false}
           src={
             event.has_snapshot
-              ? `${apiHost}api/events/${event.id}/snapshot.jpg`
-              : `${apiHost}api/events/${event.id}/thumbnail.jpg`
+              ? `${apiHost}api/media/events/${event.id}/snapshot.jpg`
+              : `${apiHost}api/media/events/${event.id}/thumbnail.jpg`
           }
         />
         {hovered && (
@@ -263,8 +263,8 @@ function EventItem({
                     download
                     href={
                       event.has_snapshot
-                        ? `${apiHost}api/events/${event.id}/snapshot.jpg`
-                        : `${apiHost}api/events/${event.id}/thumbnail.jpg`
+                        ? `${apiHost}api/media/events/${event.id}/snapshot.jpg`
+                        : `${apiHost}api/media/events/${event.id}/thumbnail.jpg`
                     }
                   >
                     <Chip className="cursor-pointer rounded-md bg-gray-500 bg-gradient-to-br from-gray-400 to-gray-500">
diff --git a/web/src/components/overlay/dialog/FrigatePlusDialog.tsx b/web/src/components/overlay/dialog/FrigatePlusDialog.tsx
index 3c5f3890d..2e39f72e9 100644
--- a/web/src/components/overlay/dialog/FrigatePlusDialog.tsx
+++ b/web/src/components/overlay/dialog/FrigatePlusDialog.tsx
@@ -95,7 +95,7 @@ export function FrigatePlusDialog({
             {upload?.id && (
               <img
                 className={`w-full ${grow} bg-black`}
-                src={`${baseUrl}api/events/${upload?.id}/snapshot.jpg`}
+                src={`${baseUrl}api/media/events/${upload?.id}/snapshot.jpg`}
                 alt={`${upload?.label}`}
               />
             )}
diff --git a/web/src/components/player/PreviewPlayer.tsx b/web/src/components/player/PreviewPlayer.tsx
index 6ff5e1590..dff56ef88 100644
--- a/web/src/components/player/PreviewPlayer.tsx
+++ b/web/src/components/player/PreviewPlayer.tsx
@@ -586,7 +586,7 @@ class PreviewFramesController extends PreviewController {
     if (this.seeking) {
       this.timeToSeek = frame;
     } else {
-      const newSrc = `${baseUrl}api/preview/preview_${this.camera}-${frame}.webp/thumbnail.webp`;
+      const newSrc = `${baseUrl}api/media/preview/preview_${this.camera}-${frame}.webp/thumbnail.webp`;
 
       if (this.imgController.current.src != newSrc) {
         this.imgController.current.src = newSrc;
@@ -603,7 +603,7 @@ class PreviewFramesController extends PreviewController {
     }
 
     if (this.timeToSeek) {
-      const newSrc = `${baseUrl}api/preview/preview_${this.camera}-${this.timeToSeek}.webp/thumbnail.webp`;
+      const newSrc = `${baseUrl}api/media/preview/preview_${this.camera}-${this.timeToSeek}.webp/thumbnail.webp`;
 
       if (this.imgController.current.src != newSrc) {
         this.imgController.current.src = newSrc;
diff --git a/web/src/components/player/dynamic/DynamicVideoPlayer.tsx b/web/src/components/player/dynamic/DynamicVideoPlayer.tsx
index 6c4e28e27..063734476 100644
--- a/web/src/components/player/dynamic/DynamicVideoPlayer.tsx
+++ b/web/src/components/player/dynamic/DynamicVideoPlayer.tsx
@@ -149,7 +149,7 @@ export default function DynamicVideoPlayer({
       }
 
       const time = controller.getProgress(playTime);
-      return axios.post(`/${camera}/plus/${time}`);
+      return axios.post(`/media/camera/${camera}/plus/${time}`);
     },
     [camera, controller],
   );
@@ -164,7 +164,7 @@ export default function DynamicVideoPlayer({
     [timeRange],
   );
   const { data: recordings } = useSWR<Recording[]>(
-    [`${camera}/recordings`, recordingParams],
+    [`media/camera/${camera}/recordings`, recordingParams],
     { revalidateOnFocus: false },
   );
 
diff --git a/web/src/components/preview/ScrubbablePreview.tsx b/web/src/components/preview/ScrubbablePreview.tsx
index eb9a962a8..9b30fc7a5 100644
--- a/web/src/components/preview/ScrubbablePreview.tsx
+++ b/web/src/components/preview/ScrubbablePreview.tsx
@@ -433,7 +433,7 @@ export function InProgressPreview({
     <div className="relative flex size-full items-center bg-black">
       <img
         className="pointer-events-none size-full object-contain"
-        src={`${apiHost}api/preview/${previewFrames[key]}/thumbnail.webp`}
+        src={`${apiHost}api/media/preview/${previewFrames[key]}/thumbnail.webp`}
         onLoad={handleLoad}
       />
       {showProgress && (
diff --git a/web/src/components/settings/PolygonCanvas.tsx b/web/src/components/settings/PolygonCanvas.tsx
index e6851b63c..8cf7faac1 100644
--- a/web/src/components/settings/PolygonCanvas.tsx
+++ b/web/src/components/settings/PolygonCanvas.tsx
@@ -42,7 +42,7 @@ export function PolygonCanvas({
       const element = new window.Image();
       element.width = width;
       element.height = height;
-      element.src = `${apiHost}api/${camera}/latest.webp?cache=${Date.now()}`;
+      element.src = `${apiHost}api/media/camera/${camera}/frame/latest?extension=webp&?cache=${Date.now()}`;
       return element;
     }
     // we know that these deps are correct
diff --git a/web/src/pages/SubmitPlus.tsx b/web/src/pages/SubmitPlus.tsx
index 96fc21787..1432c2335 100644
--- a/web/src/pages/SubmitPlus.tsx
+++ b/web/src/pages/SubmitPlus.tsx
@@ -259,7 +259,7 @@ export default function SubmitPlus() {
                     </div>
                     <img
                       className="aspect-video h-full rounded-lg object-contain md:rounded-2xl"
-                      src={`${baseUrl}api/events/${event.id}/snapshot.jpg`}
+                      src={`${baseUrl}api/media/events/${event.id}/snapshot.jpg`}
                       loading="lazy"
                     />
                   </div>
diff --git a/web/src/views/live/LiveCameraView.tsx b/web/src/views/live/LiveCameraView.tsx
index 15e08cebf..7e493615f 100644
--- a/web/src/views/live/LiveCameraView.tsx
+++ b/web/src/views/live/LiveCameraView.tsx
@@ -499,7 +499,9 @@ function PtzControlPanel({
   clickOverlay: boolean;
   setClickOverlay: React.Dispatch<React.SetStateAction<boolean>>;
 }) {
-  const { data: ptz } = useSWR<CameraPtzInfo>(`${camera}/ptz/info`);
+  const { data: ptz } = useSWR<CameraPtzInfo>(
+    `/media/camera/${camera}/ptz/info`,
+  );
 
   const { send: sendPtz } = usePtzCommand(camera);
 
diff --git a/web/src/views/system/StorageMetrics.tsx b/web/src/views/system/StorageMetrics.tsx
index 8bfa8b51f..a7a00be30 100644
--- a/web/src/views/system/StorageMetrics.tsx
+++ b/web/src/views/system/StorageMetrics.tsx
@@ -18,7 +18,7 @@ type StorageMetricsProps = {
 export default function StorageMetrics({
   setLastUpdated,
 }: StorageMetricsProps) {
-  const { data: cameraStorage } = useSWR<CameraStorage>("recordings/storage");
+  const { data: cameraStorage } = useSWR<CameraStorage>("media/recordings/storage");
   const { data: stats } = useSWR<FrigateStats>("stats");
 
   const totalStorage = useMemo(() => {