diff --git a/ErsatzTV.Application/Artworks/Commands/UploadArtwork.cs b/ErsatzTV.Application/Artworks/Commands/UploadArtwork.cs
new file mode 100644
index 000000000..e27c60b37
--- /dev/null
+++ b/ErsatzTV.Application/Artworks/Commands/UploadArtwork.cs
@@ -0,0 +1,13 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+///
+/// Validates and stores an uploaded image as channel logo or watermark artwork,
+/// landing it in the same on-disk cache the Blazor UI uses (via IImageCache),
+/// so the returned path is equivalent to a Blazor-uploaded image.
+///
+public record UploadArtwork(Stream Stream, string ContentType, ArtworkKind ArtworkKind)
+ : IRequest>;
diff --git a/ErsatzTV.Application/Artworks/Commands/UploadArtworkHandler.cs b/ErsatzTV.Application/Artworks/Commands/UploadArtworkHandler.cs
new file mode 100644
index 000000000..0133c9c39
--- /dev/null
+++ b/ErsatzTV.Application/Artworks/Commands/UploadArtworkHandler.cs
@@ -0,0 +1,53 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Images;
+
+namespace ErsatzTV.Application.Artworks;
+
+public class UploadArtworkHandler : IRequestHandler>
+{
+ // png/jpeg/gif/webp are all decoded by SkiaSharp and read by FFmpeg, matching the
+ // formats the Blazor logo/watermark upload already accepts. Format expansion is ersatztv#66.
+ private static readonly HashSet AcceptedContentTypes = new(StringComparer.OrdinalIgnoreCase)
+ {
+ "image/png",
+ "image/jpeg",
+ "image/gif",
+ "image/webp"
+ };
+
+ private readonly IImageCache _imageCache;
+
+ public UploadArtworkHandler(IImageCache imageCache) => _imageCache = imageCache;
+
+ public async Task> Handle(
+ UploadArtwork request,
+ CancellationToken cancellationToken)
+ {
+ string contentType = (request.ContentType ?? string.Empty).Trim();
+ if (!AcceptedContentTypes.Contains(contentType))
+ {
+ return BaseError.New(
+ $"Unsupported image content type '{contentType}'; supported types are: {string.Join(", ", AcceptedContentTypes)}");
+ }
+
+ Either maybeFileName = await _imageCache.SaveArtworkToCache(
+ request.Stream,
+ request.ArtworkKind);
+
+ return maybeFileName.Map(fileName => new ArtworkUploadResponseModel(
+ BuildPath(request.ArtworkKind, fileName),
+ contentType));
+ }
+
+ // Mirror the on-disk conventions the Blazor editors use so the returned path is a drop-in
+ // for ArtworkContentTypeModel.Path: channel logos are addressed as "iptv/logos/{file}"
+ // (see ChannelEditor.UploadLogo), watermarks by the bare cache file name (see WatermarkEditor).
+ private static string BuildPath(ArtworkKind artworkKind, string fileName) =>
+ artworkKind switch
+ {
+ ArtworkKind.Logo => $"iptv/logos/{fileName}",
+ _ => fileName
+ };
+}
diff --git a/ErsatzTV.Core/Api/Artwork/ArtworkUploadResponseModel.cs b/ErsatzTV.Core/Api/Artwork/ArtworkUploadResponseModel.cs
new file mode 100644
index 000000000..c743408a9
--- /dev/null
+++ b/ErsatzTV.Core/Api/Artwork/ArtworkUploadResponseModel.cs
@@ -0,0 +1,9 @@
+namespace ErsatzTV.Core.Api.Artwork;
+
+///
+/// Result of uploading channel logo / watermark artwork via the REST API.
+/// is directly consumable as the Path of an
+/// ArtworkContentTypeModel (e.g. CreateChannel.Logo / channel update),
+/// and carries the stored MIME type.
+///
+public record ArtworkUploadResponseModel(string Path, string ContentType);
diff --git a/ErsatzTV/Controllers/Api/ArtworkUploadController.cs b/ErsatzTV/Controllers/Api/ArtworkUploadController.cs
new file mode 100644
index 000000000..396e81026
--- /dev/null
+++ b/ErsatzTV/Controllers/Api/ArtworkUploadController.cs
@@ -0,0 +1,79 @@
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Extensions;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class ArtworkUploadController(IMediator mediator)
+{
+ [HttpPost("/api/artwork/uploads")]
+ [Consumes("multipart/form-data")]
+ [Tags("Artwork")]
+ [EndpointSummary("Upload channel logo or watermark artwork")]
+ [EndpointGroupName("general")]
+ [ProducesResponseType(typeof(ArtworkUploadResponseModel), StatusCodes.Status201Created)]
+ [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+ public async Task Upload(
+ IFormFile file,
+ [FromForm] string target,
+ CancellationToken cancellationToken)
+ {
+ if (file is null || file.Length == 0)
+ {
+ return BaseError.New("A non-empty image file is required").ToErrorResult();
+ }
+
+ long maxBytes = (long)SystemEnvironment.MaximumUploadMb * 1024 * 1024;
+ if (file.Length > maxBytes)
+ {
+ return BaseError.New($"Image exceeds the maximum allowed size of {SystemEnvironment.MaximumUploadMb} MB")
+ .ToErrorResult();
+ }
+
+ if (!TryParseTarget(target, out ArtworkKind artworkKind))
+ {
+ return BaseError.New($"Unknown upload target '{target}'; expected 'logo' or 'watermark'").ToErrorResult();
+ }
+
+ await using Stream stream = file.OpenReadStream();
+ Either result = await mediator.Send(
+ new UploadArtwork(stream, file.ContentType, artworkKind),
+ cancellationToken);
+
+ return result.ToCreatedResult(
+ value => LocationFor(artworkKind, value.Path),
+ value => value);
+ }
+
+ // "logo" (default) and "watermark" are the two channel-artwork surfaces the API exposes today.
+ private static bool TryParseTarget(string target, out ArtworkKind artworkKind)
+ {
+ switch ((target ?? string.Empty).Trim().ToLowerInvariant())
+ {
+ case "":
+ case "logo":
+ artworkKind = ArtworkKind.Logo;
+ return true;
+ case "watermark":
+ artworkKind = ArtworkKind.Watermark;
+ return true;
+ default:
+ artworkKind = ArtworkKind.Logo;
+ return false;
+ }
+ }
+
+ private static string LocationFor(ArtworkKind artworkKind, string path) =>
+ artworkKind switch
+ {
+ // logo paths already carry the servable prefix ("iptv/logos/{file}")
+ ArtworkKind.Logo => $"/{path}",
+ _ => $"/artwork/watermarks/{path}"
+ };
+}