feat: add distance-from-edge inset setting for backdrop ratings

Closes #7.

Some media players (e.g. Nuvio on Mac) reposition/crop backdrops and clip
the rating badges. Add two independent per-key/global settings that inset
the backdrop ratings inward from the anchored edge:

- backdrop_edge_inset_x — horizontal inset (% of width), applies only to
left/right positions
- backdrop_edge_inset_y — vertical inset (% of height), applies only to
top/bottom positions

Centered axes ignore their inset, so a top-right position exposes "space
from top" and "space from right", while "right" exposes only "space from
right". Surfaced in the settings UI as conditional, edge-aware inputs and
as edge_inset_x / edge_inset_y query params on the backdrop image and
preview endpoints.

The cache token (.eh{x}/.ev{y}) is emitted only when the position-gated
value is non-zero, mirroring the existing optional .x1 (split) and .blur
tokens, so default backdrop cache keys are unchanged and no cache-key
migration is needed (only the additive DB columns, default 0).

README.md

@@ -137,9 +137,10 @@ GET /{api_key}/isValid
 - `?blur={true|false}`: apply Gaussian blur for spoiler protection (episode only). Badges remain sharp over the blurred still image
 - `?split={true|false}`: split the badges evenly across two opposite sides of the poster (poster only). The axis follows the badge layout — a vertical layout splits left/right, horizontal rows split top/bottom. With an odd number of badges the configured side gets the extra one (e.g. 4 badges → 2 + 2, 3 badges → 2 + 1)
 - `?fit={native|cover|pad|blur}`: how a poster is fit to the standard 2:3 output frame (poster only). `native` (default) keeps the source aspect ratio; `cover` scales to fill 2:3 and center-crops the overflow; `pad` fits the whole poster inside 2:3 with solid black bars; `blur` fits the whole poster inside 2:3 and fills the bars with a blurred, zoomed copy of the poster. The non-native modes guarantee a uniform 2:3 image so downstream apps that place posters in fixed 2:3 containers don't crop the art
+- `?edge_inset_x={0-50}` / `?edge_inset_y={0-50}`: inset the backdrop ratings further from the anchored edge, as a percentage of the backdrop's width/height (backdrop only). Useful when a media player crops the backdrop and clips the ratings. `edge_inset_x` only applies to left/right positions and `edge_inset_y` only to top/bottom positions; the inset for a centered axis is ignored. Example: `?position=tr&edge_inset_y=10` nudges top-right ratings down by 10% of the height
 - RPDB-compatible — use `http://localhost:3000` as the base URL (drop-in replacement for `https://api.ratingposterdb.com`). Old parameter names `?poster_source=` and `?fanart_textless=` are accepted as aliases
 
-`textless`, `split`, and `fit` are poster-only. `blur` is episode-only. `badge_direction` and `position` are silently ignored on logo endpoints. For shared parameters (`ratings_limit`, `badge_style`, `label_style`, `badge_size`, `badge_shape`, `badge_background`, `image_source`), the override is applied to the correct image-type-specific setting (e.g. `?badge_style=h` on the poster endpoint sets `poster_badge_style`, on the logo endpoint sets `logo_badge_style`).
+`textless`, `split`, and `fit` are poster-only. `blur` is episode-only. `edge_inset_x`/`edge_inset_y` are backdrop-only. `badge_direction` and `position` are silently ignored on logo endpoints. For shared parameters (`ratings_limit`, `badge_style`, `label_style`, `badge_size`, `badge_shape`, `badge_background`, `image_source`), the override is applied to the correct image-type-specific setting (e.g. `?badge_style=h` on the poster endpoint sets `poster_badge_style`, on the logo endpoint sets `logo_badge_style`).
 
 Management endpoints (auth, keys, settings) are under `/api/` and return JSON.
 

api/src/entity/api_key_settings.rs

@@ -43,6 +43,12 @@ pub struct Model {
     pub logo_badge_background: String,
     pub backdrop_badge_background: String,
     pub episode_badge_background: String,
+    /// Distance (percent of width, 0–50) to inset backdrop ratings from the
+    /// anchored horizontal edge (left or right). Ignored for centered positions.
+    pub backdrop_edge_inset_x: i32,
+    /// Distance (percent of height, 0–50) to inset backdrop ratings from the
+    /// anchored vertical edge (top or bottom). Ignored for centered positions.
+    pub backdrop_edge_inset_y: i32,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

api/src/handlers/admin.rs

@@ -136,6 +136,8 @@ pub struct GlobalSettingsResponse {
     pub backdrop_badge_size: BadgeSize,
     pub backdrop_position: BadgePosition,
     pub backdrop_badge_direction: BadgeDirection,
+    pub backdrop_edge_inset_x: i32,
+    pub backdrop_edge_inset_y: i32,
     pub episode_ratings_limit: i32,
     pub episode_badge_style: BadgeStyle,
     pub episode_label_style: LabelStyle,
@@ -194,6 +196,8 @@ pub async fn get_settings(
         backdrop_badge_size: settings.backdrop_badge_size,
         backdrop_position: settings.backdrop_position,
         backdrop_badge_direction: settings.backdrop_badge_direction,
+        backdrop_edge_inset_x: settings.backdrop_edge_inset_x,
+        backdrop_edge_inset_y: settings.backdrop_edge_inset_y,
         episode_ratings_limit: settings.episode_ratings_limit,
         episode_badge_style: settings.episode_badge_style,
         episode_label_style: settings.episode_label_style,
@@ -261,6 +265,10 @@ pub struct UpdateGlobalSettingsRequest {
     pub backdrop_position: BadgePosition,
     #[serde(default = "db::default_backdrop_badge_direction")]
     pub backdrop_badge_direction: BadgeDirection,
+    #[serde(default = "db::default_backdrop_edge_inset")]
+    pub backdrop_edge_inset_x: i32,
+    #[serde(default = "db::default_backdrop_edge_inset")]
+    pub backdrop_edge_inset_y: i32,
     #[serde(default = "db::default_episode_ratings_limit")]
     pub episode_ratings_limit: i32,
     #[serde(default = "db::default_episode_badge_style")]
@@ -305,6 +313,8 @@ pub async fn update_settings(
     let episode_limit_str = req.episode_ratings_limit.to_string();
     let episode_blur_str = if req.episode_blur { "true" } else { "false" };
     let poster_badge_split_str = if req.poster_badge_split { "true" } else { "false" };
+    let backdrop_edge_inset_x_str = db::clamp_edge_inset(req.backdrop_edge_inset_x).to_string();
+    let backdrop_edge_inset_y_str = db::clamp_edge_inset(req.backdrop_edge_inset_y).to_string();
     let mut batch: Vec<(&str, &str)> = vec![
         ("image_source", req.image_source.as_str()),
         ("lang", &req.lang),
@@ -329,6 +339,8 @@ pub async fn update_settings(
         ("backdrop_badge_size", req.backdrop_badge_size.as_str()),
         ("backdrop_position", req.backdrop_position.as_str()),
         ("backdrop_badge_direction", req.backdrop_badge_direction.as_str()),
+        ("backdrop_edge_inset_x", &backdrop_edge_inset_x_str),
+        ("backdrop_edge_inset_y", &backdrop_edge_inset_y_str),
         ("episode_ratings_limit", &episode_limit_str),
         ("episode_badge_style", req.episode_badge_style.as_str()),
         ("episode_label_style", req.episode_label_style.as_str()),

api/src/handlers/api_keys.rs

@@ -118,6 +118,8 @@ pub struct RenderSettingsResponse {
     pub backdrop_badge_size: BadgeSize,
     pub backdrop_position: BadgePosition,
     pub backdrop_badge_direction: BadgeDirection,
+    pub backdrop_edge_inset_x: i32,
+    pub backdrop_edge_inset_y: i32,
     pub episode_ratings_limit: i32,
     pub episode_badge_style: BadgeStyle,
     pub episode_label_style: LabelStyle,
@@ -173,6 +175,8 @@ fn settings_to_response(settings: &db::RenderSettings, fanart_available: bool) -
         backdrop_badge_size: settings.backdrop_badge_size,
         backdrop_position: settings.backdrop_position,
         backdrop_badge_direction: settings.backdrop_badge_direction,
+        backdrop_edge_inset_x: settings.backdrop_edge_inset_x,
+        backdrop_edge_inset_y: settings.backdrop_edge_inset_y,
         episode_ratings_limit: settings.episode_ratings_limit,
         episode_badge_style: settings.episode_badge_style,
         episode_label_style: settings.episode_label_style,
@@ -239,6 +243,10 @@ pub struct UpdateSettingsRequest {
     pub backdrop_position: BadgePosition,
     #[serde(default = "db::default_backdrop_badge_direction")]
     pub backdrop_badge_direction: BadgeDirection,
+    #[serde(default = "db::default_backdrop_edge_inset")]
+    pub backdrop_edge_inset_x: i32,
+    #[serde(default = "db::default_backdrop_edge_inset")]
+    pub backdrop_edge_inset_y: i32,
     #[serde(default = "db::default_episode_ratings_limit")]
     pub episode_ratings_limit: i32,
     #[serde(default = "db::default_episode_badge_style")]
@@ -312,6 +320,8 @@ fn build_upsert(id: i32, req: &UpdateSettingsRequest) -> db::UpsertApiKeySetting
         logo_badge_background: req.logo_badge_background.as_str(),
         backdrop_badge_background: req.backdrop_badge_background.as_str(),
         episode_badge_background: req.episode_badge_background.as_str(),
+        backdrop_edge_inset_x: db::clamp_edge_inset(req.backdrop_edge_inset_x),
+        backdrop_edge_inset_y: db::clamp_edge_inset(req.backdrop_edge_inset_y),
     }
 }
 

api/src/handlers/image.rs

@@ -118,6 +118,16 @@ pub struct ImageQuery {
     #[serde(default)]
     #[param(value_type = Option<String>)]
     pub fit: Option<PosterFit>,
+    /// Distance (0–50, percent of width) to inset backdrop ratings from the
+    /// anchored horizontal edge (backdrop only). Ignored for centered positions.
+    #[serde(default)]
+    #[param(value_type = Option<i32>)]
+    pub edge_inset_x: Option<i32>,
+    /// Distance (0–50, percent of height) to inset backdrop ratings from the
+    /// anchored vertical edge (backdrop only). Ignored for centered positions.
+    #[serde(default)]
+    #[param(value_type = Option<i32>)]
+    pub edge_inset_y: Option<i32>,
 }
 
 impl ImageQuery {
@@ -138,6 +148,8 @@ impl ImageQuery {
             || self.blur.is_some()
             || self.split.is_some()
             || self.fit.is_some()
+            || self.edge_inset_x.is_some()
+            || self.edge_inset_y.is_some()
     }
 }
 
@@ -193,6 +205,8 @@ pub struct FreeKeySettingsResponse {
     pub backdrop_badge_size: BadgeSize,
     pub backdrop_position: BadgePosition,
     pub backdrop_badge_direction: BadgeDirection,
+    pub backdrop_edge_inset_x: i32,
+    pub backdrop_edge_inset_y: i32,
     pub episode_ratings_limit: i32,
     pub episode_badge_style: BadgeStyle,
     pub episode_label_style: LabelStyle,
@@ -236,6 +250,8 @@ impl From<&RenderSettings> for FreeKeySettingsResponse {
             backdrop_badge_size: s.backdrop_badge_size,
             backdrop_position: s.backdrop_position,
             backdrop_badge_direction: s.backdrop_badge_direction,
+            backdrop_edge_inset_x: s.backdrop_edge_inset_x,
+            backdrop_edge_inset_y: s.backdrop_edge_inset_y,
             episode_ratings_limit: s.episode_ratings_limit,
             episode_badge_style: s.episode_badge_style,
             episode_label_style: s.episode_label_style,
@@ -451,6 +467,12 @@ fn apply_query_overrides(
         if let Some(pos) = query.position {
             s.backdrop_position = pos;
         }
+        if let Some(inset) = query.edge_inset_x {
+            s.backdrop_edge_inset_x = db::clamp_edge_inset(inset);
+        }
+        if let Some(inset) = query.edge_inset_y {
+            s.backdrop_edge_inset_y = db::clamp_edge_inset(inset);
+        }
     }
     if kind == cache::ImageType::Episode {
         if let Some(dir) = query.badge_direction {
@@ -876,6 +898,8 @@ mod tests {
             blur: None,
             split: None,
             fit: None,
+            edge_inset_x: None,
+            edge_inset_y: None,
         }
     }
 
@@ -980,6 +1004,50 @@ mod tests {
         assert_eq!(result.poster_badge_direction, original_poster_direction);
     }
 
+    #[test]
+    fn apply_query_overrides_backdrop_edge_inset() {
+        let settings = Arc::new(db::RenderSettings::default());
+        let query = ImageQuery {
+            edge_inset_x: Some(12),
+            edge_inset_y: Some(7),
+            ..empty_query()
+        };
+        let result =
+            apply_query_overrides(settings, &query, cache::ImageType::Backdrop).unwrap();
+        assert_eq!(result.backdrop_edge_inset_x, 12);
+        assert_eq!(result.backdrop_edge_inset_y, 7);
+    }
+
+    #[test]
+    fn apply_query_overrides_clamps_out_of_range_edge_inset() {
+        let settings = Arc::new(db::RenderSettings::default());
+        let query = ImageQuery {
+            edge_inset_x: Some(999),
+            edge_inset_y: Some(-5),
+            ..empty_query()
+        };
+        let result =
+            apply_query_overrides(settings, &query, cache::ImageType::Backdrop).unwrap();
+        assert_eq!(result.backdrop_edge_inset_x, db::MAX_EDGE_INSET);
+        assert_eq!(result.backdrop_edge_inset_y, 0);
+    }
+
+    #[test]
+    fn apply_query_overrides_edge_inset_ignored_for_poster() {
+        let settings = Arc::new(db::RenderSettings::default());
+        let query = ImageQuery {
+            edge_inset_x: Some(20),
+            edge_inset_y: Some(20),
+            ..empty_query()
+        };
+        // edge_inset counts as an override (forces a fresh Arc) but only the
+        // backdrop path consumes it — posters are unaffected.
+        let result =
+            apply_query_overrides(settings, &query, cache::ImageType::Poster).unwrap();
+        assert_eq!(result.backdrop_edge_inset_x, 0);
+        assert_eq!(result.backdrop_edge_inset_y, 0);
+    }
+
     #[test]
     fn apply_query_overrides_rejects_invalid_ratings_limit() {
         let settings = Arc::new(db::RenderSettings::default());

api/src/handlers/preview.rs

@@ -318,8 +318,12 @@ pub async fn preview_backdrop(
     let badge_style = query.badge_style.unwrap_or(BadgeStyle::Vertical).resolve(badge_direction);
     let label_style = query.label_style.unwrap_or(db::default_label_style());
     let badge_appearance = preview_badge_appearance(&query);
+    let edge_inset_x = db::clamp_edge_inset(query.edge_inset_x.unwrap_or(0));
+    let edge_inset_y = db::clamp_edge_inset(query.edge_inset_y.unwrap_or(0));
     let ratings_suffix = ratings::ratings_cache_suffix(ratings_order, ratings_exclude, ratings_limit);
-    let preview_settings = preview_render_settings(cache::ImageType::Backdrop, badge_style, label_style, badge_size, position, badge_direction, badge_appearance, ratings_limit, ratings_order, ratings_exclude);
+    let mut preview_settings = preview_render_settings(cache::ImageType::Backdrop, badge_style, label_style, badge_size, position, badge_direction, badge_appearance, ratings_limit, ratings_order, ratings_exclude);
+    preview_settings.backdrop_edge_inset_x = edge_inset_x;
+    preview_settings.backdrop_edge_inset_y = edge_inset_y;
     let suffix = serve::settings_cache_suffix_with_ratings(&preview_settings, cache::ImageType::Backdrop, image_size, &ratings_suffix);
     let cache_key = format!("preview-backdrop:{suffix}");
     let cache_path = cache::preview_path(&state.config.cache_dir, cache::ImageType::Backdrop, &suffix, "jpg")?;
@@ -342,7 +346,7 @@ pub async fn preview_backdrop(
     let quality = state.config.image_quality;
 
     let buf = tokio::task::spawn_blocking(move || {
-        generate::render_backdrop_sync(backdrop_png, &badges, &font, quality, position, badge_style, label_style, badge_appearance, badge_direction, target_width, badge_scale, badge_size)
+        generate::render_backdrop_sync(backdrop_png, &badges, &font, quality, position, badge_style, label_style, badge_appearance, badge_direction, target_width, badge_scale, badge_size, edge_inset_x, edge_inset_y)
     })
     .await
     .map_err(|e| AppError::Other(e.to_string()))??;

api/src/image/generate.rs

@@ -150,7 +150,13 @@ pub async fn generate_poster(params: ImageParams<'_>) -> Result<Vec<u8>, AppErro
 }
 
 /// Overlay badges in a vertical column, positioned according to `position`.
-fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], position: BadgePosition, badge_scale: f32, side_margin_base: u32) {
+///
+/// `extra_x` / `extra_y` are additional edge insets in pixels (already resolved
+/// for this canvas) that push the badges further from the anchored edge. They
+/// only take effect on the edge the position anchors to: `extra_y` on top/bottom
+/// anchors, `extra_x` on left/right anchors. Centered axes ignore their inset.
+/// Callers that don't want insets pass `0, 0`.
+fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], position: BadgePosition, badge_scale: f32, side_margin_base: u32, extra_x: u32, extra_y: u32) {
     let vert_spacing = (BADGE_VERT_SPACING as f32 * badge_scale).round() as u32;
     let top_margin = (BADGE_TOP_MARGIN as f32 * badge_scale).round() as u32;
     let bottom_margin = (BADGE_BOTTOM_MARGIN as f32 * badge_scale).round() as u32;
@@ -162,9 +168,9 @@ fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], po
 
     // Vertical anchor
     let start_y = if position.is_top() {
-        top_margin
+        top_margin + extra_y
     } else if position.is_bottom() {
-        canvas.height().saturating_sub(total_badge_height + bottom_margin)
+        canvas.height().saturating_sub(total_badge_height + bottom_margin + extra_y)
     } else {
         // "l", "r" — vertically centered
         (canvas.height().saturating_sub(total_badge_height)) / 2
@@ -175,9 +181,9 @@ fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], po
     let is_right = position.is_right();
 
     let base_x = if is_left {
-        side_margin
+        side_margin + extra_x
     } else if is_right {
-        canvas.width().saturating_sub(max_badge_width + side_margin)
+        canvas.width().saturating_sub(max_badge_width + side_margin + extra_x)
     } else {
         // center
         (canvas.width().saturating_sub(max_badge_width)) / 2
@@ -198,7 +204,11 @@ fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], po
 }
 
 /// Overlay badges in horizontal rows, positioned according to `position`.
-fn overlay_horizontal_rows(canvas: &mut RgbaImage, badge_images: &[RgbaImage], position: BadgePosition, max_per_row: usize, badge_scale: f32, side_margin_base: u32) {
+///
+/// `extra_x` / `extra_y` behave as in [`overlay_vertical_stack`]: edge insets in
+/// resolved pixels that only apply to the anchored edge (centered axes ignore
+/// them). Callers that don't want insets pass `0, 0`.
+fn overlay_horizontal_rows(canvas: &mut RgbaImage, badge_images: &[RgbaImage], position: BadgePosition, max_per_row: usize, badge_scale: f32, side_margin_base: u32, extra_x: u32, extra_y: u32) {
     let spacing = (BADGE_SPACING as f32 * badge_scale).round() as u32;
     let row_spacing = (BADGE_ROW_SPACING as f32 * badge_scale).round() as u32;
     let top_margin = (BADGE_TOP_MARGIN as f32 * badge_scale).round() as u32;
@@ -212,9 +222,9 @@ fn overlay_horizontal_rows(canvas: &mut RgbaImage, badge_images: &[RgbaImage], p
 
     // Vertical anchor
     let base_y = if position.is_top() {
-        top_margin
+        top_margin + extra_y
     } else if position.is_bottom() {
-        canvas.height().saturating_sub(total_height + bottom_margin)
+        canvas.height().saturating_sub(total_height + bottom_margin + extra_y)
     } else {
         // "l", "r" — vertically centered
         (canvas.height().saturating_sub(total_height)) / 2
@@ -230,9 +240,9 @@ fn overlay_horizontal_rows(canvas: &mut RgbaImage, badge_images: &[RgbaImage], p
         let y = base_y + row_idx as u32 * (badge_height + row_spacing);
 
         let start_x = if is_left {
-            side_margin
+            side_margin + extra_x
         } else if is_right {
-            canvas.width().saturating_sub(row_width + side_margin)
+            canvas.width().saturating_sub(row_width + side_margin + extra_x)
         } else {
             (canvas.width().saturating_sub(row_width)) / 2
         };
@@ -405,9 +415,9 @@ fn overlay_poster_group(
     badge_scale: f32,
 ) {
     if badge_direction.is_vertical() {
-        overlay_vertical_stack(canvas, badge_images, position, badge_scale, BADGE_SIDE_MARGIN);
+        overlay_vertical_stack(canvas, badge_images, position, badge_scale, BADGE_SIDE_MARGIN, 0, 0);
     } else {
-        overlay_horizontal_rows(canvas, badge_images, position, max_per_row, badge_scale, BADGE_SIDE_MARGIN);
+        overlay_horizontal_rows(canvas, badge_images, position, max_per_row, badge_scale, BADGE_SIDE_MARGIN, 0, 0);
     }
 }
 
@@ -611,6 +621,8 @@ pub fn render_backdrop_sync(
     target_width: u32,
     badge_scale: f32,
     _badge_size: BadgeSize,
+    edge_inset_x: i32,
+    edge_inset_y: i32,
 ) -> Result<Vec<u8>, AppError> {
     // A pill is a horizontal lozenge (icon/label left, value right) — never a
     // vertical stacked badge, even when the configured style is vertical.
@@ -634,11 +646,19 @@ pub fn render_backdrop_sync(
             badge::render_badges_uniform(badges, font, label_style, badge_appearance, badge_scale)
         };
 
+        // Edge insets are a percentage of the canvas dimension, so they stay
+        // proportional across image sizes (small/medium/large). The overlay
+        // functions only apply each axis on the edge the position anchors to.
+        let inset_pct_x = edge_inset_x.clamp(0, 100) as f32 / 100.0;
+        let inset_pct_y = edge_inset_y.clamp(0, 100) as f32 / 100.0;
+        let extra_x = (canvas.width() as f32 * inset_pct_x).round() as u32;
+        let extra_y = (canvas.height() as f32 * inset_pct_y).round() as u32;
+
         if badge_direction.is_vertical() {
-            overlay_vertical_stack(&mut canvas, &badge_images, position, badge_scale, BACKDROP_SIDE_MARGIN);
+            overlay_vertical_stack(&mut canvas, &badge_images, position, badge_scale, BACKDROP_SIDE_MARGIN, extra_x, extra_y);
         } else {
             // Backdrops are wide (16:9) so all badges fit in a single row
-            overlay_horizontal_rows(&mut canvas, &badge_images, position, badge_images.len(), badge_scale, BACKDROP_SIDE_MARGIN);
+            overlay_horizontal_rows(&mut canvas, &badge_images, position, badge_images.len(), badge_scale, BACKDROP_SIDE_MARGIN, extra_x, extra_y);
         }
     }
 
@@ -665,6 +685,8 @@ pub async fn generate_backdrop(
     target_width: u32,
     badge_scale: f32,
     badge_size: BadgeSize,
+    edge_inset_x: i32,
+    edge_inset_y: i32,
 ) -> Result<Vec<u8>, AppError> {
     if render_semaphore.available_permits() == 0 {
         tracing::debug!("render queue full, waiting for permit");
@@ -674,7 +696,7 @@ pub async fn generate_backdrop(
     tracing::debug!("backdrop render started");
     let start = std::time::Instant::now();
 
-    let buf = tokio::task::spawn_blocking(move || render_backdrop_sync(&backdrop_bytes, &badges, &font, quality, position, badge_style, label_style, badge_appearance, badge_direction, target_width, badge_scale, badge_size))
+    let buf = tokio::task::spawn_blocking(move || render_backdrop_sync(&backdrop_bytes, &badges, &font, quality, position, badge_style, label_style, badge_appearance, badge_direction, target_width, badge_scale, badge_size, edge_inset_x, edge_inset_y))
         .await
         .map_err(|e| AppError::Other(e.to_string()))??;
 
@@ -733,7 +755,7 @@ pub fn render_episode_sync(
         };
 
         if badge_direction.is_vertical() {
-            overlay_vertical_stack(&mut canvas, &badge_images, position, badge_scale, BADGE_SIDE_MARGIN);
+            overlay_vertical_stack(&mut canvas, &badge_images, position, badge_scale, BADGE_SIDE_MARGIN, 0, 0);
         } else {
             let max_per_row = match badge_size {
                 BadgeSize::Large | BadgeSize::ExtraLarge => {
@@ -743,7 +765,7 @@ pub fn render_episode_sync(
                     if badge_style.is_vertical() { MAX_VERT_BADGES_PER_ROW } else { MAX_BADGES_PER_ROW }
                 }
             };
-            overlay_horizontal_rows(&mut canvas, &badge_images, position, max_per_row, badge_scale, BADGE_SIDE_MARGIN);
+            overlay_horizontal_rows(&mut canvas, &badge_images, position, max_per_row, badge_scale, BADGE_SIDE_MARGIN, 0, 0);
         }
     }
 
@@ -920,7 +942,7 @@ mod tests {
     fn render_backdrop_no_badges() {
         let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
         let png = test_png(640, 360);
-        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium).unwrap();
+        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
         assert!(!result.is_empty());
         // Backdrop outputs JPEG
         assert_eq!(result[0], 0xFF);
@@ -937,7 +959,7 @@ mod tests {
             RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
             RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
         ];
-        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium).unwrap();
+        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
         assert!(!result.is_empty());
         assert_eq!(result[0], 0xFF);
         assert_eq!(result[1], 0xD8);
@@ -948,7 +970,7 @@ mod tests {
         let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
         // Create a backdrop wider than TARGET_WIDTH (1280)
         let png = test_png(2560, 1440);
-        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium).unwrap();
+        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
         assert!(!result.is_empty());
         assert_eq!(result[0], 0xFF);
         assert_eq!(result[1], 0xD8);
@@ -957,7 +979,7 @@ mod tests {
     #[test]
     fn render_backdrop_invalid_bytes() {
         let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
-        let result = render_backdrop_sync(b"not an image", &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium);
+        let result = render_backdrop_sync(b"not an image", &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0);
         assert!(result.is_err());
     }
 
@@ -971,7 +993,7 @@ mod tests {
             RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
             RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
         ];
-        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 1280, 1.0, BadgeSize::Medium).unwrap();
+        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
         assert!(!result.is_empty());
         assert_eq!(result[0], 0xFF);
         assert_eq!(result[1], 0xD8);
@@ -989,7 +1011,7 @@ mod tests {
             RatingBadge { source: RatingSource::RtAudience, value: "80%".to_string() },
         ];
         // Large + Horizontal style — all badges in a single row on wide backdrop
-        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 1280, 1.0, BadgeSize::Large).unwrap();
+        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Horizontal, 1280, 1.0, BadgeSize::Large, 0, 0).unwrap();
         assert!(!result.is_empty());
         assert_eq!(result[0], 0xFF);
         assert_eq!(result[1], 0xD8);
@@ -1004,12 +1026,42 @@ mod tests {
         let badges = vec![
             RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
         ];
-        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomLeft, BadgeStyle::Vertical, LabelStyle::Icon, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium).unwrap();
+        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::BottomLeft, BadgeStyle::Vertical, LabelStyle::Icon, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
         assert!(!result.is_empty());
         assert_eq!(result[0], 0xFF);
         assert_eq!(result[1], 0xD8);
     }
 
+    #[test]
+    fn render_backdrop_edge_inset_shifts_only_active_axis() {
+        use crate::services::ratings::{RatingBadge, RatingSource};
+
+        let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
+        let png = test_png(1280, 720);
+        let badges = vec![
+            RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
+            RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
+        ];
+        let render = |pos: BadgePosition, x: i32, y: i32| {
+            render_backdrop_sync(&png, &badges, &font, 85, pos, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, x, y).unwrap()
+        };
+
+        // TopRight anchors to both a horizontal and vertical edge, so both insets
+        // move the badges (the JPEG encoder is deterministic, so bytes differ).
+        assert_ne!(render(BadgePosition::TopRight, 0, 0), render(BadgePosition::TopRight, 10, 0));
+        assert_ne!(render(BadgePosition::TopRight, 0, 0), render(BadgePosition::TopRight, 0, 10));
+
+        // TopCenter is horizontally centered → the horizontal inset is a no-op,
+        // but the vertical inset still applies.
+        assert_eq!(render(BadgePosition::TopCenter, 0, 0), render(BadgePosition::TopCenter, 10, 0));
+        assert_ne!(render(BadgePosition::TopCenter, 0, 0), render(BadgePosition::TopCenter, 0, 10));
+
+        // Right is vertically centered → the vertical inset is a no-op, but the
+        // horizontal inset still applies.
+        assert_eq!(render(BadgePosition::Right, 0, 0), render(BadgePosition::Right, 0, 10));
+        assert_ne!(render(BadgePosition::Right, 0, 0), render(BadgePosition::Right, 10, 0));
+    }
+
     // --- Episode rendering tests ---
 
     #[test]
@@ -1189,7 +1241,7 @@ mod tests {
             RatingBadge { source: RatingSource::Imdb, value: "9.0".to_string() },
             RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
         ];
-        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Icon, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium).unwrap();
+        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Icon, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
         assert!(!result.is_empty());
         assert_eq!(result[0], 0xFF);
         assert_eq!(result[1], 0xD8);
@@ -1237,7 +1289,7 @@ mod tests {
             RatingBadge { source: RatingSource::Rt, value: "95%".to_string() },
             RatingBadge { source: RatingSource::RtAudience, value: "40%".to_string() },
         ];
-        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium).unwrap();
+        let result = render_backdrop_sync(&png, &badges, &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Official, BadgeAppearance::default(), BadgeDirection::Vertical, 1280, 1.0, BadgeSize::Medium, 0, 0).unwrap();
         assert!(!result.is_empty());
         assert_eq!(result[0], 0xFF);
         assert_eq!(result[1], 0xD8);
@@ -1350,7 +1402,7 @@ mod tests {
         let png = test_png(640, 360);
         let sem = Arc::new(Semaphore::new(1));
 
-        let result = generate_backdrop(png, vec![], font, 85, BadgePosition::TopRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, sem.clone(), 1280, 1.0, BadgeSize::Medium).await;
+        let result = generate_backdrop(png, vec![], font, 85, BadgePosition::TopRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, sem.clone(), 1280, 1.0, BadgeSize::Medium, 0, 0).await;
         assert!(result.is_ok());
         assert_eq!(sem.available_permits(), 1);
     }
@@ -1362,7 +1414,7 @@ mod tests {
         let sem = Arc::new(Semaphore::new(1));
         sem.close();
 
-        let result = generate_backdrop(png, vec![], font, 85, BadgePosition::TopRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, sem, 1280, 1.0, BadgeSize::Medium).await;
+        let result = generate_backdrop(png, vec![], font, 85, BadgePosition::TopRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, sem, 1280, 1.0, BadgeSize::Medium, 0, 0).await;
         assert!(result.is_err());
     }
 
@@ -1692,7 +1744,7 @@ mod tests {
     fn render_backdrop_at_large_target_width() {
         let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
         let png = test_png(640, 360);
-        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 3840, 2.0, BadgeSize::Medium).unwrap();
+        let result = render_backdrop_sync(&png, &[], &font, 85, BadgePosition::TopRight, BadgeStyle::Vertical, LabelStyle::Text, BadgeAppearance::default(), BadgeDirection::Vertical, 3840, 2.0, BadgeSize::Medium, 0, 0).unwrap();
         assert!(!result.is_empty());
         assert_eq!(result[0], 0xFF);
         assert_eq!(result[1], 0xD8);

api/src/image/serve.rs

@@ -51,6 +51,9 @@ struct LbRenderParams {
     label_style: LabelStyle,
     badge_size: BadgeSize,
     appearance: BadgeAppearance,
+    /// Backdrop edge insets (percent of dimension). Zero for logos.
+    edge_inset_x: i32,
+    edge_inset_y: i32,
 }
 
 impl LbRenderParams {
@@ -80,7 +83,15 @@ impl LbRenderParams {
             LogoBackdropKind::Logo => settings.logo_appearance(),
             LogoBackdropKind::Backdrop => settings.backdrop_appearance(),
         };
-        Self { position, badge_direction, badge_style, label_style, badge_size, appearance }
+        // Edge insets are backdrop-only; logos render at a fixed anchor.
+        let (edge_inset_x, edge_inset_y) = match lb_kind {
+            LogoBackdropKind::Logo => (0, 0),
+            LogoBackdropKind::Backdrop => (
+                crate::services::db::clamp_edge_inset(settings.backdrop_edge_inset_x),
+                crate::services::db::clamp_edge_inset(settings.backdrop_edge_inset_y),
+            ),
+        };
+        Self { position, badge_direction, badge_style, label_style, badge_size, appearance, edge_inset_x, edge_inset_y }
     }
 }
 
@@ -114,6 +125,24 @@ pub fn badge_background_cache_suffix(background: &str) -> String {
     format!(".bg{background}")
 }
 
+/// Returns a cache key suffix for the backdrop edge inset.
+///
+/// Empty when the (position-gated) inset is zero, so the default configuration
+/// keeps its existing cache keys — no migration needed. This mirrors the
+/// optional `.x1` (poster split) and `.blur` (episode) tokens. Each axis is only
+/// tokenized when it actually affects placement: horizontal for left/right
+/// positions, vertical for top/bottom positions.
+pub fn edge_inset_cache_suffix(position: BadgePosition, inset_x: i32, inset_y: i32) -> String {
+    let mut out = String::new();
+    if (position.is_left() || position.is_right()) && inset_x > 0 {
+        out.push_str(&format!(".eh{inset_x}"));
+    }
+    if (position.is_top() || position.is_bottom()) && inset_y > 0 {
+        out.push_str(&format!(".ev{inset_y}"));
+    }
+    out
+}
+
 /// Resolve an optional image size, defaulting to Medium.
 pub fn resolve_image_size(size: Option<ImageSize>) -> ImageSize {
     size.unwrap_or(ImageSize::Medium)
@@ -183,6 +212,8 @@ pub fn settings_cache_suffix_with_ratings(
         backdrop_badge_size: _,
         backdrop_position: _,
         backdrop_badge_direction: _,
+        backdrop_edge_inset_x: _,
+        backdrop_edge_inset_y: _,
         episode_ratings_limit: _,
         episode_badge_style: _,
         episode_label_style: _,
@@ -243,7 +274,10 @@ pub fn settings_cache_suffix_with_ratings(
             let bsz = settings.backdrop_badge_size.cache_suffix();
             let shp = badge_shape_cache_suffix(settings.backdrop_badge_shape.as_str());
             let bgd = badge_background_cache_suffix(settings.backdrop_badge_background.as_str());
-            format!("{rs}{ps}{bs}{ls}{bd}{bsz}{shp}{bgd}{is_suffix}")
+            // Edge inset sits after background (before image size) and is only
+            // present when non-zero, so default backdrop keys are unchanged.
+            let ei = edge_inset_cache_suffix(settings.backdrop_position, settings.backdrop_edge_inset_x, settings.backdrop_edge_inset_y);
+            format!("{rs}{ps}{bs}{ls}{bd}{bsz}{shp}{bgd}{ei}{is_suffix}")
         }
         cache::ImageType::Episode => {
             let ps = position_cache_suffix(settings.episode_position.as_str());
@@ -1165,7 +1199,7 @@ fn trigger_logo_backdrop_refresh(
         };
         let bytes = match lb_kind {
             LogoBackdropKind::Logo => generate::generate_logo(image_bytes, badges, state2.font.clone(), params.badge_style, params.label_style, params.appearance, state2.render_semaphore.clone(), target_width, badge_scale).await?,
-            LogoBackdropKind::Backdrop => generate::generate_backdrop(image_bytes, badges, state2.font.clone(), state2.config.image_quality, params.position, params.badge_style, params.label_style, params.appearance, params.badge_direction, state2.render_semaphore.clone(), target_width, badge_scale, params.badge_size).await?,
+            LogoBackdropKind::Backdrop => generate::generate_backdrop(image_bytes, badges, state2.font.clone(), state2.config.image_quality, params.position, params.badge_style, params.label_style, params.appearance, params.badge_direction, state2.render_semaphore.clone(), target_width, badge_scale, params.badge_size, params.edge_inset_x, params.edge_inset_y).await?,
         };
 
         Ok((bytes, cross_ids.release_date.clone(), image_type, cross_ids))
@@ -1901,6 +1935,8 @@ pub async fn handle_logo_backdrop_inner(
         type_position: BadgePosition,
         type_badge_direction: BadgeDirection,
         type_badge_size: BadgeSize,
+        type_edge_inset_x: i32,
+        type_edge_inset_y: i32,
         badge_size_factor: f32,
         label: &'static str,
         resolved: id::ResolvedId,
@@ -1923,6 +1959,8 @@ pub async fn handle_logo_backdrop_inner(
         type_position: params.position,
         type_badge_direction: params.badge_direction,
         type_badge_size: params.badge_size,
+        type_edge_inset_x: params.edge_inset_x,
+        type_edge_inset_y: params.edge_inset_y,
         badge_size_factor: params.badge_size.scale_factor(),
         label,
         resolved: resolved.clone(),
@@ -2006,7 +2044,7 @@ pub async fn handle_logo_backdrop_inner(
             };
             let bytes = match lb_kind {
                 LogoBackdropKind::Logo => generate::generate_logo(image_bytes, ctx.badges, ctx.state.font.clone(), ctx.type_badge_style, ctx.type_label_style, ctx.type_appearance, ctx.state.render_semaphore.clone(), target_width, badge_scale).await?,
-                LogoBackdropKind::Backdrop => generate::generate_backdrop(image_bytes, ctx.badges, ctx.state.font.clone(), ctx.state.config.image_quality, ctx.type_position, ctx.type_badge_style, ctx.type_label_style, ctx.type_appearance, ctx.type_badge_direction, ctx.state.render_semaphore.clone(), target_width, badge_scale, ctx.type_badge_size).await?,
+                LogoBackdropKind::Backdrop => generate::generate_backdrop(image_bytes, ctx.badges, ctx.state.font.clone(), ctx.state.config.image_quality, ctx.type_position, ctx.type_badge_style, ctx.type_label_style, ctx.type_appearance, ctx.type_badge_direction, ctx.state.render_semaphore.clone(), target_width, badge_scale, ctx.type_badge_size, ctx.type_edge_inset_x, ctx.type_edge_inset_y).await?,
             };
 
             let release_date = ctx.cross_ids.release_date.clone();
@@ -2523,6 +2561,51 @@ mod tests {
         assert_eq!(p.badge_style, BadgeStyle::Vertical);
     }
 
+    #[test]
+    fn lb_render_params_backdrop_reads_edge_insets() {
+        let settings = RenderSettings {
+            backdrop_position: BadgePosition::TopRight,
+            backdrop_edge_inset_x: 8,
+            backdrop_edge_inset_y: 3,
+            ..RenderSettings::default()
+        };
+        let p = LbRenderParams::from_settings(LogoBackdropKind::Backdrop, &settings);
+        assert_eq!(p.edge_inset_x, 8);
+        assert_eq!(p.edge_inset_y, 3);
+        // Logos never inset.
+        let logo = LbRenderParams::from_settings(LogoBackdropKind::Logo, &settings);
+        assert_eq!(logo.edge_inset_x, 0);
+        assert_eq!(logo.edge_inset_y, 0);
+    }
+
+    #[test]
+    fn edge_inset_suffix_only_tokenizes_active_axes() {
+        // Corner: both axes apply.
+        assert_eq!(edge_inset_cache_suffix(BadgePosition::TopRight, 8, 3), ".eh8.ev3");
+        assert_eq!(edge_inset_cache_suffix(BadgePosition::BottomLeft, 5, 10), ".eh5.ev10");
+        // Right edge is vertically centered → vertical inset is dropped.
+        assert_eq!(edge_inset_cache_suffix(BadgePosition::Right, 8, 3), ".eh8");
+        // Top center is horizontally centered → horizontal inset is dropped.
+        assert_eq!(edge_inset_cache_suffix(BadgePosition::TopCenter, 8, 3), ".ev3");
+        // Zero (or default) insets add no token, so existing keys are unchanged.
+        assert_eq!(edge_inset_cache_suffix(BadgePosition::TopRight, 0, 0), "");
+    }
+
+    #[test]
+    fn backdrop_cache_suffix_includes_edge_inset_only_when_set() {
+        let base = RenderSettings { backdrop_position: BadgePosition::TopRight, ..RenderSettings::default() };
+        let without = settings_cache_suffix(&base, cache::ImageType::Backdrop, None);
+        let with = settings_cache_suffix(
+            &RenderSettings { backdrop_edge_inset_x: 8, backdrop_edge_inset_y: 3, ..base.clone() },
+            cache::ImageType::Backdrop,
+            None,
+        );
+        // Default (0/0) must match the pre-feature key; a non-zero inset diverges.
+        assert!(!without.contains(".eh") && !without.contains(".ev"));
+        assert!(with.contains(".eh8.ev3"));
+        assert_ne!(without, with);
+    }
+
     #[test]
     fn tmdb_poster_variant_all_combinations() {
         // Default case: no variant (backward compatible)

api/src/lib.rs

@@ -386,4 +386,12 @@ pub const MIGRATIONS: &[(&str, &str)] = &[
         "ALTER TABLE api_key_settings ADD COLUMN poster_fit TEXT NOT NULL DEFAULT 'native'",
         "duplicate column",
     ),
+    (
+        "ALTER TABLE api_key_settings ADD COLUMN backdrop_edge_inset_x INTEGER NOT NULL DEFAULT 0",
+        "duplicate column",
+    ),
+    (
+        "ALTER TABLE api_key_settings ADD COLUMN backdrop_edge_inset_y INTEGER NOT NULL DEFAULT 0",
+        "duplicate column",
+    ),
 ];

api/src/services/db.rs

@@ -659,6 +659,21 @@ pub fn default_backdrop_badge_direction() -> BadgeDirection {
     BadgeDirection::Default
 }
 
+/// Maximum backdrop edge inset, expressed as a percentage of the image
+/// dimension. Capped at half so the inset can never push past the centre.
+pub const MAX_EDGE_INSET: i32 = 50;
+
+pub fn default_backdrop_edge_inset() -> i32 {
+    0
+}
+
+/// Clamp a stored/requested edge inset to the supported `0..=MAX_EDGE_INSET`
+/// range so out-of-range values can never produce runaway cache keys or
+/// nonsensical placement.
+pub fn clamp_edge_inset(value: i32) -> i32 {
+    value.clamp(0, MAX_EDGE_INSET)
+}
+
 // --- Badge size ---
 
 pub fn default_badge_size() -> BadgeSize {
@@ -2003,6 +2018,8 @@ pub struct UpsertApiKeySettings<'a> {
     pub logo_badge_background: &'a str,
     pub backdrop_badge_background: &'a str,
     pub episode_badge_background: &'a str,
+    pub backdrop_edge_inset_x: i32,
+    pub backdrop_edge_inset_y: i32,
 }
 
 pub async fn upsert_api_key_settings(
@@ -2049,6 +2066,8 @@ pub async fn upsert_api_key_settings(
         logo_badge_background: Set(params.logo_badge_background.to_string()),
         backdrop_badge_background: Set(params.backdrop_badge_background.to_string()),
         episode_badge_background: Set(params.episode_badge_background.to_string()),
+        backdrop_edge_inset_x: Set(params.backdrop_edge_inset_x),
+        backdrop_edge_inset_y: Set(params.backdrop_edge_inset_y),
     };
     api_key_settings::Entity::insert(model)
         .on_conflict(
@@ -2092,6 +2111,8 @@ pub async fn upsert_api_key_settings(
                     api_key_settings::Column::LogoBadgeBackground,
                     api_key_settings::Column::BackdropBadgeBackground,
                     api_key_settings::Column::EpisodeBadgeBackground,
+                    api_key_settings::Column::BackdropEdgeInsetX,
+                    api_key_settings::Column::BackdropEdgeInsetY,
                 ])
                 .to_owned(),
         )
@@ -2143,6 +2164,12 @@ pub struct RenderSettings {
     pub backdrop_badge_size: BadgeSize,
     pub backdrop_position: BadgePosition,
     pub backdrop_badge_direction: BadgeDirection,
+    /// Inset (percent of width) of backdrop ratings from the anchored
+    /// horizontal edge. Only applies to left/right positions.
+    pub backdrop_edge_inset_x: i32,
+    /// Inset (percent of height) of backdrop ratings from the anchored
+    /// vertical edge. Only applies to top/bottom positions.
+    pub backdrop_edge_inset_y: i32,
     pub episode_ratings_limit: i32,
     pub episode_badge_style: BadgeStyle,
     pub episode_label_style: LabelStyle,
@@ -2206,6 +2233,8 @@ impl Default for RenderSettings {
             backdrop_badge_size: BadgeSize::Medium,
             backdrop_position: default_backdrop_position(),
             backdrop_badge_direction: default_backdrop_badge_direction(),
+            backdrop_edge_inset_x: default_backdrop_edge_inset(),
+            backdrop_edge_inset_y: default_backdrop_edge_inset(),
             episode_ratings_limit: default_episode_ratings_limit(),
             episode_badge_style: default_episode_badge_style(),
             episode_label_style: default_label_style(),
@@ -2278,6 +2307,16 @@ pub fn parse_global_render_settings(globals: &HashMap<String, String>) -> Render
         backdrop_badge_size: global_or(globals, "backdrop_badge_size", BadgeSize::parse, defaults.backdrop_badge_size),
         backdrop_position: global_or(globals, "backdrop_position", BadgePosition::parse, defaults.backdrop_position),
         backdrop_badge_direction: global_or(globals, "backdrop_badge_direction", BadgeDirection::parse, defaults.backdrop_badge_direction),
+        backdrop_edge_inset_x: globals
+            .get("backdrop_edge_inset_x")
+            .and_then(|v| v.parse().ok())
+            .map(clamp_edge_inset)
+            .unwrap_or(defaults.backdrop_edge_inset_x),
+        backdrop_edge_inset_y: globals
+            .get("backdrop_edge_inset_y")
+            .and_then(|v| v.parse().ok())
+            .map(clamp_edge_inset)
+            .unwrap_or(defaults.backdrop_edge_inset_y),
         episode_ratings_limit: globals
             .get("episode_ratings_limit")
             .and_then(|v| v.parse().ok())
@@ -2335,6 +2374,8 @@ pub async fn get_effective_render_settings(
                 backdrop_badge_size: parse_setting_or_default(&s.backdrop_badge_size, "backdrop_badge_size", BadgeSize::parse, BadgeSize::Medium),
                 backdrop_position: parse_setting_or_default(&s.backdrop_position, "backdrop_position", BadgePosition::parse, default_backdrop_position()),
                 backdrop_badge_direction: parse_setting_or_default(&s.backdrop_badge_direction, "backdrop_badge_direction", BadgeDirection::parse, default_backdrop_badge_direction()),
+                backdrop_edge_inset_x: clamp_edge_inset(s.backdrop_edge_inset_x),
+                backdrop_edge_inset_y: clamp_edge_inset(s.backdrop_edge_inset_y),
                 episode_ratings_limit: s.episode_ratings_limit,
                 episode_badge_style: parse_setting_or_default(&s.episode_badge_style, "episode_badge_style", BadgeStyle::parse, default_episode_badge_style()),
                 episode_label_style: parse_setting_or_default(&s.episode_label_style, "episode_label_style", LabelStyle::parse, LabelStyle::Official),

api/tests/db_operations.rs

@@ -45,6 +45,8 @@ fn test_upsert(key_id: i32) -> UpsertApiKeySettings<'static> {
         logo_badge_background: "d",
         backdrop_badge_background: "d",
         episode_badge_background: "d",
+        backdrop_edge_inset_x: 0,
+        backdrop_edge_inset_y: 0,
     }
 }
 

api/tests/preview.rs

@@ -169,6 +169,34 @@ async fn preview_cache_differs_for_different_params() {
     assert_ne!(body1, body2);
 }
 
+#[tokio::test]
+async fn preview_backdrop_edge_inset_shifts_only_active_axis() {
+    let (app, _state) = common::setup_test_app().await;
+    let token = common::setup_admin(&app).await;
+
+    let fetch = |q: &str| {
+        let app = app.clone();
+        let token = token.clone();
+        let uri = format!("/api/admin/preview/backdrop?{q}");
+        async move {
+            let res = app.oneshot(authed_get(&uri, &token)).await.unwrap();
+            assert_eq!(res.status(), StatusCode::OK);
+            res.into_body().collect().await.unwrap().to_bytes()
+        }
+    };
+
+    // Top-right anchors to both edges → both insets change the rendered image.
+    let base = fetch("position=tr").await;
+    assert_ne!(base, fetch("position=tr&edge_inset_x=12").await);
+    assert_ne!(base, fetch("position=tr&edge_inset_y=8").await);
+
+    // Top-center is horizontally centered → the horizontal inset is a no-op and
+    // must reuse the same cache key / image, while the vertical inset applies.
+    let tc = fetch("position=tc").await;
+    assert_eq!(tc, fetch("position=tc&edge_inset_x=12").await);
+    assert_ne!(tc, fetch("position=tc&edge_inset_y=8").await);
+}
+
 #[tokio::test]
 async fn preview_cache_populates_entry_count() {
     let (app, state) = common::setup_test_app().await;

web/src/__tests__/components/RenderSettingsForm.spec.ts

@@ -32,6 +32,8 @@ const defaultSettings: RenderSettings = {
   backdrop_badge_size: 'm',
   backdrop_position: 'tr',
   backdrop_badge_direction: 'v',
+  backdrop_edge_inset_x: 0,
+  backdrop_edge_inset_y: 0,
   episode_ratings_limit: 1,
   episode_badge_style: 'v',
   episode_label_style: 'o',
@@ -369,4 +371,82 @@ describe('RenderSettingsForm', () => {
     expect(wrapper.find('[data-testid="episode-badge-direction-select"]').exists()).toBe(true)
     expect(wrapper.find('[data-testid="episode-blur-checkbox"]').exists()).toBe(true)
   })
+
+  // --- Backdrop edge inset ---
+
+  function mountWithBackdrop(
+    overrides: Partial<RenderSettings> = {},
+    fetchBackdropPreview = makeFetchPreview(),
+    saveSettings = vi.fn().mockResolvedValue(null),
+  ) {
+    const settings = { ...defaultSettings, ...overrides }
+    return mount(RenderSettingsForm, {
+      props: {
+        settings,
+        loadSettings: vi.fn().mockResolvedValue(settings),
+        saveSettings,
+        fetchPreview: makeFetchPreview(),
+        fetchBackdropPreview,
+      },
+      global: {
+        plugins: [createPinia()],
+        stubs: shadcnStubs,
+      },
+    })
+  }
+
+  it('shows both edge-inset inputs for a corner backdrop position', () => {
+    const wrapper = mountWithBackdrop({ backdrop_position: 'tr' })
+    expect(wrapper.find('[data-testid="backdrop-edge-inset-x"]').exists()).toBe(true)
+    expect(wrapper.find('[data-testid="backdrop-edge-inset-y"]').exists()).toBe(true)
+    expect(wrapper.text()).toContain('Space from top')
+    expect(wrapper.text()).toContain('Space from right')
+  })
+
+  it('shows only the vertical edge-inset input for a top-center position', () => {
+    const wrapper = mountWithBackdrop({ backdrop_position: 'tc' })
+    expect(wrapper.find('[data-testid="backdrop-edge-inset-x"]').exists()).toBe(false)
+    expect(wrapper.find('[data-testid="backdrop-edge-inset-y"]').exists()).toBe(true)
+    expect(wrapper.text()).toContain('Space from top')
+  })
+
+  it('shows only the horizontal edge-inset input for a right position', () => {
+    const wrapper = mountWithBackdrop({ backdrop_position: 'r' })
+    expect(wrapper.find('[data-testid="backdrop-edge-inset-x"]').exists()).toBe(true)
+    expect(wrapper.find('[data-testid="backdrop-edge-inset-y"]').exists()).toBe(false)
+    expect(wrapper.text()).toContain('Space from right')
+  })
+
+  it('passes edge insets to fetchBackdropPreview', async () => {
+    const fetchBackdropPreview = makeFetchPreview()
+    mountWithBackdrop({ backdrop_position: 'tr', backdrop_edge_inset_x: 12, backdrop_edge_inset_y: 7 }, fetchBackdropPreview)
+    await flushPromises()
+
+    expect(fetchBackdropPreview).toHaveBeenCalledWith(
+      3, // backdrop_ratings_limit
+      expect.any(String), // ratings_order
+      'v', // backdrop_badge_style
+      'i', // backdrop_label_style
+      'm', // backdrop_badge_size
+      'tr', // backdrop_position
+      'v', // backdrop_badge_direction
+      '', // ratings_exclude
+      'r', // backdrop_badge_shape
+      'd', // backdrop_badge_background
+      12, // backdrop_edge_inset_x
+      7, // backdrop_edge_inset_y
+    )
+  })
+
+  it('editing a backdrop edge inset auto-saves the new value', async () => {
+    const saveSettings = vi.fn().mockResolvedValue(null)
+    const wrapper = mountWithBackdrop({ backdrop_position: 'tr' }, makeFetchPreview(), saveSettings)
+
+    await wrapper.find('[data-testid="backdrop-edge-inset-y"]').setValue(15)
+    await flushPromises()
+
+    expect(saveSettings).toHaveBeenCalledWith(
+      expect.objectContaining({ backdrop_edge_inset_y: 15 }),
+    )
+  })
 })

web/src/components/RenderSettingsForm.vue

@@ -42,6 +42,8 @@ export interface RenderSettings {
   backdrop_badge_size: string
   backdrop_position: string
   backdrop_badge_direction: string
+  backdrop_edge_inset_x: number
+  backdrop_edge_inset_y: number
   episode_ratings_limit: number
   episode_badge_style: string
   episode_label_style: string
@@ -67,7 +69,7 @@ const props = defineProps<{
   resetSettings?: () => Promise<boolean>
   fetchPreview: (ratingsLimit: number, ratingsOrder: string, posterPosition?: string, badgeStyle?: string, labelStyle?: string, badgeDirection?: string, badgeSize?: string, ratingsExclude?: string, posterSplit?: boolean, badgeShape?: string, badgeBackground?: string, posterFit?: string) => Promise<Response>
   fetchLogoPreview?: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string) => Promise<Response>
-  fetchBackdropPreview?: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string) => Promise<Response>
+  fetchBackdropPreview?: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string, edgeInsetX?: number, edgeInsetY?: number) => Promise<Response>
   fetchEpisodePreview?: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, blur?: boolean, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string) => Promise<Response>
 }>()
 
@@ -97,6 +99,8 @@ const editLogoBadgeSize = ref(props.settings.logo_badge_size || 'm')
 const editBackdropBadgeSize = ref(props.settings.backdrop_badge_size || 'm')
 const editBackdropPosition = ref(props.settings.backdrop_position || 'tr')
 const editBackdropBadgeDirection = ref(props.settings.backdrop_badge_direction || 'd')
+const editBackdropEdgeInsetX = ref(props.settings.backdrop_edge_inset_x ?? 0)
+const editBackdropEdgeInsetY = ref(props.settings.backdrop_edge_inset_y ?? 0)
 const editEpisodeRatingsLimit = ref(props.settings.episode_ratings_limit ?? 1)
 const editEpisodeBadgeStyle = ref(props.settings.episode_badge_style || 'v')
 const editEpisodeLabelStyle = ref(props.settings.episode_label_style || 'o')
@@ -113,6 +117,18 @@ const editLogoBadgeBackground = ref(props.settings.logo_badge_background || 'd')
 const editBackdropBadgeBackground = ref(props.settings.backdrop_badge_background || 'd')
 const editEpisodeBadgeBackground = ref(props.settings.episode_badge_background || 'd')
 
+// Which edges the current backdrop position anchors to. The horizontal inset
+// only applies to left/right positions and the vertical inset only to top/bottom
+// positions; centered axes hide their control (and the server ignores them).
+const backdropIsTop = computed(() => ['tl', 'tc', 'tr'].includes(editBackdropPosition.value))
+const backdropIsBottom = computed(() => ['bl', 'bc', 'br'].includes(editBackdropPosition.value))
+const backdropIsLeft = computed(() => ['tl', 'bl', 'l'].includes(editBackdropPosition.value))
+const backdropIsRight = computed(() => ['tr', 'br', 'r'].includes(editBackdropPosition.value))
+const backdropShowVerticalInset = computed(() => backdropIsTop.value || backdropIsBottom.value)
+const backdropShowHorizontalInset = computed(() => backdropIsLeft.value || backdropIsRight.value)
+const backdropVerticalInsetLabel = computed(() => (backdropIsTop.value ? 'Space from top' : 'Space from bottom'))
+const backdropHorizontalInsetLabel = computed(() => (backdropIsLeft.value ? 'Space from left' : 'Space from right'))
+
 function applySettings(s: RenderSettings) {
   editFanart.value = s.image_source === 'f'
   editLang.value = s.lang || 'en'
@@ -137,6 +153,8 @@ function applySettings(s: RenderSettings) {
   editBackdropBadgeSize.value = s.backdrop_badge_size || 'm'
   editBackdropPosition.value = s.backdrop_position || 'tr'
   editBackdropBadgeDirection.value = s.backdrop_badge_direction || 'd'
+  editBackdropEdgeInsetX.value = s.backdrop_edge_inset_x ?? 0
+  editBackdropEdgeInsetY.value = s.backdrop_edge_inset_y ?? 0
   editEpisodeRatingsLimit.value = s.episode_ratings_limit ?? 1
   editEpisodeBadgeStyle.value = s.episode_badge_style || 'v'
   editEpisodeLabelStyle.value = s.episode_label_style || 'o'
@@ -211,6 +229,8 @@ async function autoSave() {
       backdrop_badge_size: editBackdropBadgeSize.value,
       backdrop_position: editBackdropPosition.value,
       backdrop_badge_direction: editBackdropBadgeDirection.value,
+      backdrop_edge_inset_x: editBackdropEdgeInsetX.value,
+      backdrop_edge_inset_y: editBackdropEdgeInsetY.value,
       episode_ratings_limit: editEpisodeRatingsLimit.value,
       episode_badge_style: editEpisodeBadgeStyle.value,
       episode_label_style: editEpisodeLabelStyle.value,
@@ -252,7 +272,7 @@ async function autoSave() {
 
 // Auto-save on any setting change
 watch(
-  [editSource, editLang, editTextless, editRatingsLimit, editRatingsOrder, editRatingsExclude, editPosterPosition, editLogoRatingsLimit, editBackdropRatingsLimit, editPosterBadgeStyle, editLogoBadgeStyle, editBackdropBadgeStyle, editPosterLabelStyle, editLogoLabelStyle, editBackdropLabelStyle, editPosterBadgeDirection, editPosterBadgeSplit, editPosterFit, editPosterBadgeSize, editLogoBadgeSize, editBackdropBadgeSize, editBackdropPosition, editBackdropBadgeDirection, editEpisodeRatingsLimit, editEpisodeBadgeStyle, editEpisodeLabelStyle, editEpisodeBadgeSize, editEpisodePosition, editEpisodeBadgeDirection, editEpisodeBlur, editPosterBadgeShape, editLogoBadgeShape, editBackdropBadgeShape, editEpisodeBadgeShape, editPosterBadgeBackground, editLogoBadgeBackground, editBackdropBadgeBackground, editEpisodeBadgeBackground],
+  [editSource, editLang, editTextless, editRatingsLimit, editRatingsOrder, editRatingsExclude, editPosterPosition, editLogoRatingsLimit, editBackdropRatingsLimit, editPosterBadgeStyle, editLogoBadgeStyle, editBackdropBadgeStyle, editPosterLabelStyle, editLogoLabelStyle, editBackdropLabelStyle, editPosterBadgeDirection, editPosterBadgeSplit, editPosterFit, editPosterBadgeSize, editLogoBadgeSize, editBackdropBadgeSize, editBackdropPosition, editBackdropBadgeDirection, editBackdropEdgeInsetX, editBackdropEdgeInsetY, editEpisodeRatingsLimit, editEpisodeBadgeStyle, editEpisodeLabelStyle, editEpisodeBadgeSize, editEpisodePosition, editEpisodeBadgeDirection, editEpisodeBlur, editPosterBadgeShape, editLogoBadgeShape, editBackdropBadgeShape, editEpisodeBadgeShape, editPosterBadgeBackground, editLogoBadgeBackground, editBackdropBadgeBackground, editEpisodeBadgeBackground],
   () => {
     if (syncing) return
     autoSave()
@@ -354,7 +374,7 @@ function updateLogoPreview() {
 
 function updateBackdropPreview() {
   if (props.fetchBackdropPreview) {
-    fetchPreviewImage(backdropPreview.value, (_limit, order) => props.fetchBackdropPreview!(editBackdropRatingsLimit.value, order, editBackdropBadgeStyle.value, editBackdropLabelStyle.value, editBackdropBadgeSize.value, editBackdropPosition.value, editBackdropBadgeDirection.value, editRatingsExclude.value.join(','), editBackdropBadgeShape.value, editBackdropBadgeBackground.value))
+    fetchPreviewImage(backdropPreview.value, (_limit, order) => props.fetchBackdropPreview!(editBackdropRatingsLimit.value, order, editBackdropBadgeStyle.value, editBackdropLabelStyle.value, editBackdropBadgeSize.value, editBackdropPosition.value, editBackdropBadgeDirection.value, editRatingsExclude.value.join(','), editBackdropBadgeShape.value, editBackdropBadgeBackground.value, editBackdropEdgeInsetX.value, editBackdropEdgeInsetY.value))
   }
 }
 
@@ -399,7 +419,7 @@ watch([editLogoRatingsLimit, editLogoBadgeStyle, editLogoLabelStyle, editLogoBad
 })
 
 // Backdrop-only settings
-watch([editBackdropRatingsLimit, editBackdropBadgeStyle, editBackdropLabelStyle, editBackdropBadgeSize, editBackdropPosition, editBackdropBadgeDirection, editBackdropBadgeShape, editBackdropBadgeBackground], () => {
+watch([editBackdropRatingsLimit, editBackdropBadgeStyle, editBackdropLabelStyle, editBackdropBadgeSize, editBackdropPosition, editBackdropBadgeDirection, editBackdropEdgeInsetX, editBackdropEdgeInsetY, editBackdropBadgeShape, editBackdropBadgeBackground], () => {
   if (syncing) return
   if (backdropPreviewTimer) clearTimeout(backdropPreviewTimer)
   backdropPreviewTimer = setTimeout(updateBackdropPreview, 500)
@@ -962,6 +982,42 @@ function toggleExclude(key: string, checked: boolean) {
               </SelectContent>
             </Select>
           </div>
+          <div v-if="backdropShowVerticalInset || backdropShowHorizontalInset" class="space-y-1">
+            <Label>Distance from edge</Label>
+            <div class="flex flex-wrap gap-4">
+              <div v-if="backdropShowVerticalInset" class="space-y-1">
+                <Label :for="inputId('backdrop-edge-inset-y')" class="text-xs font-normal text-muted-foreground">{{ backdropVerticalInsetLabel }}</Label>
+                <div class="flex items-center gap-1">
+                  <Input
+                    :id="inputId('backdrop-edge-inset-y')"
+                    v-model.number="editBackdropEdgeInsetY"
+                    type="number"
+                    :min="0"
+                    :max="50"
+                    class="w-[80px]"
+                    data-testid="backdrop-edge-inset-y"
+                  />
+                  <span class="text-xs text-muted-foreground">%</span>
+                </div>
+              </div>
+              <div v-if="backdropShowHorizontalInset" class="space-y-1">
+                <Label :for="inputId('backdrop-edge-inset-x')" class="text-xs font-normal text-muted-foreground">{{ backdropHorizontalInsetLabel }}</Label>
+                <div class="flex items-center gap-1">
+                  <Input
+                    :id="inputId('backdrop-edge-inset-x')"
+                    v-model.number="editBackdropEdgeInsetX"
+                    type="number"
+                    :min="0"
+                    :max="50"
+                    class="w-[80px]"
+                    data-testid="backdrop-edge-inset-x"
+                  />
+                  <span class="text-xs text-muted-foreground">%</span>
+                </div>
+              </div>
+            </div>
+            <p class="text-xs text-muted-foreground">Inset ratings from the image edge (% of size) — useful when a player crops the backdrop.</p>
+          </div>
           <div class="space-y-2">
             <Label :for="inputId('backdrop-badge-direction')">Badge direction</Label>
             <Select

web/src/lib/api.ts

@@ -88,6 +88,8 @@ export interface SaveSettingsPayload {
   backdrop_badge_size: string
   backdrop_position: string
   backdrop_badge_direction: string
+  backdrop_edge_inset_x: number
+  backdrop_edge_inset_y: number
   episode_ratings_limit: number
   episode_badge_style: string
   episode_label_style: string
@@ -151,8 +153,8 @@ export const adminApi = {
     get(buildUrl('/api/admin/preview/poster', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, position: posterPosition, badge_style: badgeStyle, label_style: labelStyle, badge_direction: badgeDirection, badge_size: badgeSize, split: posterSplit ? 'true' : undefined, badge_shape: badgeShape, badge_background: badgeBackground, fit: posterFit })),
   previewLogo: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string): Promise<Response> =>
     get(buildUrl('/api/admin/preview/logo', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize, badge_shape: badgeShape, badge_background: badgeBackground })),
-  previewBackdrop: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string): Promise<Response> =>
-    get(buildUrl('/api/admin/preview/backdrop', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize, position, badge_direction: badgeDirection, badge_shape: badgeShape, badge_background: badgeBackground })),
+  previewBackdrop: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string, edgeInsetX?: number, edgeInsetY?: number): Promise<Response> =>
+    get(buildUrl('/api/admin/preview/backdrop', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize, position, badge_direction: badgeDirection, badge_shape: badgeShape, badge_background: badgeBackground, edge_inset_x: edgeInsetX, edge_inset_y: edgeInsetY })),
   previewEpisode: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, blur?: boolean, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string): Promise<Response> =>
     get(buildUrl('/api/admin/preview/episode', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize, position, badge_direction: badgeDirection, blur: blur ? 'true' : undefined, badge_shape: badgeShape, badge_background: badgeBackground })),
 }
@@ -190,8 +192,8 @@ export const selfApi = {
     keyRequest(buildUrl('/api/key/me/preview/poster', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, position: posterPosition, badge_style: badgeStyle, label_style: labelStyle, badge_direction: badgeDirection, badge_size: badgeSize, split: posterSplit ? 'true' : undefined, badge_shape: badgeShape, badge_background: badgeBackground, fit: posterFit })),
   previewLogo: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string): Promise<Response> =>
     keyRequest(buildUrl('/api/key/me/preview/logo', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize, badge_shape: badgeShape, badge_background: badgeBackground })),
-  previewBackdrop: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string): Promise<Response> =>
-    keyRequest(buildUrl('/api/key/me/preview/backdrop', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize, position, badge_direction: badgeDirection, badge_shape: badgeShape, badge_background: badgeBackground })),
+  previewBackdrop: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string, edgeInsetX?: number, edgeInsetY?: number): Promise<Response> =>
+    keyRequest(buildUrl('/api/key/me/preview/backdrop', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize, position, badge_direction: badgeDirection, badge_shape: badgeShape, badge_background: badgeBackground, edge_inset_x: edgeInsetX, edge_inset_y: edgeInsetY })),
   previewEpisode: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string, position?: string, badgeDirection?: string, blur?: boolean, ratingsExclude?: string, badgeShape?: string, badgeBackground?: string): Promise<Response> =>
     keyRequest(buildUrl('/api/key/me/preview/episode', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, ratings_exclude: ratingsExclude, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize, position, badge_direction: badgeDirection, blur: blur ? 'true' : undefined, badge_shape: badgeShape, badge_background: badgeBackground })),
 }

web/src/lib/auth-api.ts

@@ -29,6 +29,8 @@ export interface FreeKeyDefaults {
   backdrop_badge_size: string
   backdrop_position: string
   backdrop_badge_direction: string
+  backdrop_edge_inset_x: number
+  backdrop_edge_inset_y: number
   episode_ratings_limit: number
   episode_badge_style: string
   episode_label_style: string