diff --git a/README.md b/README.md
index c493cd14fb..bda7ed5a4f 100644
--- a/README.md
+++ b/README.md
@@ -460,7 +460,7 @@ Options:
           which have multiple extensions, e.g. HTML files with both .html and .htm extensions, you need to
           specify both extensions explicitly.
 
-          [default: md,mkd,mdx,mdown,mdwn,mkdn,mkdown,markdown,html,htm,txt]
+          [default: md,mkd,mdx,mdown,mdwn,mkdn,mkdown,markdown,html,htm,css,txt]
 
   -f, --format <FORMAT>
           Output format of final status report
diff --git a/lychee-bin/src/options.rs b/lychee-bin/src/options.rs
index 857c3f6b64..b5bb70c142 100644
--- a/lychee-bin/src/options.rs
+++ b/lychee-bin/src/options.rs
@@ -4,7 +4,7 @@ use crate::parse::parse_base;
 use crate::verbosity::Verbosity;
 use anyhow::{Context, Error, Result, anyhow};
 use clap::builder::PossibleValuesParser;
-use clap::{Parser, arg, builder::TypedValueParser};
+use clap::{Parser, builder::TypedValueParser};
 use const_format::{concatcp, formatcp};
 use http::{
     HeaderMap,
diff --git a/lychee-lib/src/extract/css.rs b/lychee-lib/src/extract/css.rs
new file mode 100644
index 0000000000..4aa048fb4b
--- /dev/null
+++ b/lychee-lib/src/extract/css.rs
@@ -0,0 +1,439 @@
+//! Extract URLs from CSS content
+//!
+//! This module extracts URLs from CSS files and `<style>` tags.
+//! It looks for `url()` functions which are commonly used for:
+//! - background-image
+//! - background
+//! - @import statements
+//! - font-face src
+//! - etc.
+// NOTE: this is a regular-expression based extractor and may not cover all edge
+// cases of CSS parsing. Specifically, it does not handle escape sequences
+// within URLs or nested functions, such as `url("image\"name.png")`.
+//
+// A more bespoke CSS parser, such as Servo's
+// [cssparser](https://github.com/servo/rust-cssparser) crate might or might not
+// cover these cases better, but it would come with the additional burden of
+// adding multiple dependencies.
+//
+// For the time being, we accept these limitations, but we may revisit this
+// decision in the future if needed.
+
+use std::sync::LazyLock;
+
+use regex::Regex;
+
+use crate::types::uri::raw::{RawUri, SourceSpanProvider, SpanProvider};
+
+/// Regular expression to match CSS `url()` functions
+///
+/// This regex matches:
+/// - url("...")
+/// - url('...')
+/// - url(...)
+///
+/// It captures the URL inside the parentheses, handling:
+/// - Single quotes
+/// - Double quotes
+/// - No quotes
+/// - Escaped quotes within the URL
+///
+/// Examples:
+/// - `background-image: url("./image.png");`
+/// - `background: url('/path/to/image.jpg');`
+/// - `@import url(https://example.com/style.css);`
+/// - `src: url(../fonts/font.woff2);`
+static CSS_URL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(
+        r#"(?x)                     # Enable extended mode for whitespace and comments
+        url\s*\(                    # Match 'url(' with optional whitespace
+        \s*                         # Optional whitespace
+        (?:                         # Non-capturing group for the URL
+            "(?P<double>[^"]*)"     # Double-quoted URL
+            |                       # OR
+            '(?P<single>[^']*)'     # Single-quoted URL
+            |                       # OR
+            (?P<unquoted>[^)]+)     # Unquoted URL (anything until ')')
+        )
+        \s*                         # Optional whitespace
+        \)                          # Match closing ')'
+        "#,
+    )
+    .expect("CSS URL regex should be valid")
+});
+
+/// Extract all URLs from CSS content
+///
+/// This function finds all `url()` occurrences in CSS and extracts the URLs.
+///
+/// # Arguments
+///
+/// * `input` - The CSS content to extract URLs from
+/// * `span_provider` - Provides source location information for extracted URLs
+///
+/// # Returns
+///
+/// A vector of `RawUri` objects representing the extracted URLs
+///
+/// # Examples
+///
+/// CSS input:
+/// ```css
+/// .example {
+///     background-image: url("./image.png");
+///     background: url('/absolute/path.jpg');
+/// }
+/// @import url(https://example.com/style.css);
+/// ```
+///
+/// Extracts 3 URLs: `./image.png`, `/absolute/path.jpg`, and `https://example.com/style.css`
+pub(crate) fn extract_css<S: SpanProvider>(input: &str, span_provider: &S) -> Vec<RawUri> {
+    CSS_URL_REGEX
+        .captures_iter(input)
+        .filter_map(|cap| {
+            // Try to extract the URL from any of the three capture groups
+            let url = cap
+                .name("double")
+                .or_else(|| cap.name("single"))
+                .or_else(|| cap.name("unquoted"))
+                .map(|m| m.as_str().trim())?;
+
+            // Skip empty URLs. Example input: `url("")`
+            if url.is_empty() {
+                return None;
+            }
+
+            // Get the position of the entire match (for span information)
+            let match_start = cap.get(0)?.start();
+
+            Some(RawUri {
+                text: url.to_string(),
+                element: Some("style".to_string()),
+                attribute: Some("url".to_string()),
+                span: span_provider.span(match_start),
+            })
+        })
+        .collect()
+}
+
+/// Extract URLs from CSS content with default span
+pub(crate) fn extract_css_with_default_span(input: &str) -> Vec<RawUri> {
+    extract_css(input, &SourceSpanProvider::from_input(input))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Tests based on MDN documentation:
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/url_function
+
+    // Basic usage examples
+
+    #[test]
+    fn test_basic_usage_double_quotes() {
+        let css = r#"url("https://example.com/images/myImg.jpg");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "https://example.com/images/myImg.jpg");
+    }
+
+    #[test]
+    fn test_basic_usage_single_quotes() {
+        let css = r"url('https://example.com/images/myImg.jpg');";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "https://example.com/images/myImg.jpg");
+    }
+
+    #[test]
+    fn test_basic_usage_unquoted() {
+        let css = r"url(https://example.com/images/myImg.jpg);";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "https://example.com/images/myImg.jpg");
+    }
+
+    #[test]
+    fn test_data_url() {
+        let css = r#"url("data:image/jpeg;base64,iRxVB0…");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert!(urls[0].text.starts_with("data:image/jpeg"));
+    }
+
+    #[test]
+    fn test_relative_url() {
+        let css = r"url(myImg.jpg);";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "myImg.jpg");
+    }
+
+    #[test]
+    fn test_svg_fragment() {
+        let css = r"url(#IDofSVGpath);";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "#IDofSVGpath");
+    }
+
+    // Associated properties
+
+    #[test]
+    fn test_background_image() {
+        let css = r#"background-image: url("star.gif");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "star.gif");
+    }
+
+    #[test]
+    fn test_list_style_image() {
+        let css = r"list-style-image: url('../images/bullet.jpg');";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "../images/bullet.jpg");
+    }
+
+    #[test]
+    fn test_content_property() {
+        let css = r#"content: url("my-icon.jpg");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "my-icon.jpg");
+    }
+
+    #[test]
+    fn test_cursor_property() {
+        let css = r"cursor: url(my-cursor.cur);";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "my-cursor.cur");
+    }
+
+    #[test]
+    fn test_border_image_source() {
+        let css = r"border-image-source: url(/media/diamonds.png);";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "/media/diamonds.png");
+    }
+
+    #[test]
+    fn test_font_src() {
+        let css = r"src: url('fantastic-font.woff');";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "fantastic-font.woff");
+    }
+
+    #[test]
+    fn test_offset_path() {
+        let css = r"offset-path: url(#path);";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "#path");
+    }
+
+    #[test]
+    fn test_mask_image_with_fragment() {
+        let css = r#"mask-image: url("masks.svg#mask1");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "masks.svg#mask1");
+    }
+
+    // Properties with fallbacks
+
+    #[test]
+    fn test_cursor_with_fallback() {
+        let css = r"cursor: url(pointer.cur), pointer;";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "pointer.cur");
+    }
+
+    // Shorthand properties
+
+    #[test]
+    fn test_background_shorthand() {
+        let css = r"background: url('star.gif') bottom right repeat-x blue;";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "star.gif");
+    }
+
+    #[test]
+    fn test_border_image_shorthand() {
+        let css = r#"border-image: url("/media/diamonds.png") 30 fill / 30px / 30px space;"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "/media/diamonds.png");
+    }
+
+    // As parameter in CSS functions
+
+    #[test]
+    fn test_cross_fade_function() {
+        let css = r"background-image: cross-fade(20% url(first.png), url(second.png));";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 2);
+        assert_eq!(urls[0].text, "first.png");
+        assert_eq!(urls[1].text, "second.png");
+    }
+
+    #[test]
+    fn test_image_function() {
+        let css =
+            r"mask-image: image(url(mask.png), skyblue, linear-gradient(black, transparent));";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "mask.png");
+    }
+
+    // Multiple values
+
+    #[test]
+    fn test_multiple_urls_in_content() {
+        let css =
+            r"content: url(star.svg) url(star.svg) url(star.svg) url(star.svg) url(star.svg);";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 5);
+        for url in &urls {
+            assert_eq!(url.text, "star.svg");
+        }
+    }
+
+    // At-rules
+
+    #[test]
+    fn test_document_rule() {
+        let css = r#"@document url("https://www.example.com/") { }"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "https://www.example.com/");
+    }
+
+    #[test]
+    fn test_import_rule() {
+        let css = r#"@import url("https://www.example.com/style.css");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "https://www.example.com/style.css");
+    }
+
+    #[test]
+    fn test_namespace_rule() {
+        let css = r"@namespace url(http://www.w3.org/1999/xhtml);";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "http://www.w3.org/1999/xhtml");
+    }
+
+    // Complex real-world examples
+
+    #[test]
+    fn test_data_url_svg_embedded() {
+        let css = r#"background: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='90' height='45'%3E%3Cpath d='M10 10h60' stroke='%2300F' stroke-width='5'/%3E%3Cpath d='M10 20h60' stroke='%230F0' stroke-width='5'/%3E%3Cpath d='M10 30h60' stroke='red' stroke-width='5'/%3E%3C/svg%3E");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert!(urls[0].text.starts_with("data:image/svg+xml"));
+        assert!(urls[0].text.contains("%3Csvg"));
+    }
+
+    #[test]
+    fn test_filter_svg_file() {
+        let css = r#"filter: url("my-file.svg#svg-blur");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "my-file.svg#svg-blur");
+    }
+
+    #[test]
+    fn test_filter_svg_inline() {
+        let css = r##"filter: url("#svg-blur");"##;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "#svg-blur");
+    }
+
+    #[test]
+    fn test_extract_multiple_urls() {
+        let css = r#"
+        .example {
+            background-image: url("./image.png");
+            background: url('/absolute/path.jpg');
+        }
+        @import url(https://example.com/style.css);
+        @font-face {
+            src: url(../fonts/font.woff2);
+        }
+        "#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 4);
+        assert_eq!(urls[0].text, "./image.png");
+        assert_eq!(urls[1].text, "/absolute/path.jpg");
+        assert_eq!(urls[2].text, "https://example.com/style.css");
+        assert_eq!(urls[3].text, "../fonts/font.woff2");
+    }
+
+    #[test]
+    fn test_extract_url_with_spaces() {
+        let css = r#"background: url(  "./image.png"  );"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "./image.png");
+    }
+
+    #[test]
+    fn test_empty_url() {
+        let css = r#"background: url("");"#;
+        let urls = extract_css_with_default_span(css);
+        // Empty URLs should be skipped
+        assert_eq!(urls.len(), 0);
+    }
+
+    #[test]
+    fn test_no_urls() {
+        let css = r"
+        .example {
+            color: red;
+            font-size: 16px;
+        }
+        ";
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 0);
+    }
+
+    #[test]
+    fn test_url_in_style_tag_content() {
+        // This simulates content that would be inside a <style> tag in HTML
+        let css = r#"
+        div {
+            background-image: url("./lychee.png");
+        }
+        "#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].text, "./lychee.png");
+    }
+
+    #[test]
+    fn test_data_url_is_extracted() {
+        // Data URLs should still be extracted (even though they might be filtered later)
+        let css = r#"background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert!(urls[0].text.starts_with("data:image/png"));
+    }
+
+    #[test]
+    fn test_element_and_attribute_metadata() {
+        let css = r#"background: url("./image.png");"#;
+        let urls = extract_css_with_default_span(css);
+        assert_eq!(urls.len(), 1);
+        assert_eq!(urls[0].element, Some("style".to_string()));
+        assert_eq!(urls[0].attribute, Some("url".to_string()));
+    }
+}
diff --git a/lychee-lib/src/extract/html/html5ever.rs b/lychee-lib/src/extract/html/html5ever.rs
index fae25d6161..0812ba6e0b 100644
--- a/lychee-lib/src/extract/html/html5ever.rs
+++ b/lychee-lib/src/extract/html/html5ever.rs
@@ -7,7 +7,8 @@ use html5ever::{
 };
 
 use super::{
-    super::plaintext::extract_raw_uri_from_plaintext, is_email_link, is_verbatim_elem, srcset,
+    super::{css::extract_css_with_default_span, plaintext::extract_raw_uri_from_plaintext},
+    is_email_link, is_verbatim_elem, srcset,
 };
 use crate::types::uri::raw::{RawUri, RawUriSpan, SourceSpanProvider, SpanProvider};
 
@@ -40,6 +41,10 @@ struct LinkExtractor {
     links: RefCell<Vec<RawUri>>,
     include_verbatim: bool,
     current_verbatim_element_name: RefCell<Option<String>>,
+    /// Whether we're currently inside a `<style>` tag.
+    in_style_tag: RefCell<bool>,
+    /// Accumulated CSS content from within a `<style>` tag.
+    style_content: RefCell<String>,
 }
 
 impl TokenSink for LinkExtractor {
@@ -53,6 +58,12 @@ impl TokenSink for LinkExtractor {
 
         match token {
             Token::CharacterTokens(raw) => {
+                // If we're inside a style tag, accumulate the CSS content
+                if *self.in_style_tag.borrow() {
+                    self.style_content.borrow_mut().push_str(&raw);
+                    return TokenSinkResult::Continue;
+                }
+
                 if self.current_verbatim_element_name.borrow().is_some() {
                     return TokenSinkResult::Continue;
                 }
@@ -94,6 +105,8 @@ impl LinkExtractor {
             links: RefCell::new(Vec::new()),
             include_verbatim,
             current_verbatim_element_name: RefCell::new(None),
+            in_style_tag: RefCell::new(false),
+            style_content: RefCell::new(String::new()),
         }
     }
 
@@ -107,6 +120,24 @@ impl LinkExtractor {
         }: Tag,
         line_number: usize,
     ) -> TokenSinkResult<()> {
+        // Handle style tags for CSS URL extraction
+        if &name == "style" {
+            match kind {
+                TagKind::StartTag => {
+                    *self.in_style_tag.borrow_mut() = true;
+                    self.style_content.borrow_mut().clear();
+                }
+                TagKind::EndTag => {
+                    *self.in_style_tag.borrow_mut() = false;
+                    // Extract CSS URLs from the accumulated style content
+                    let css_content = self.style_content.borrow();
+                    let css_urls = extract_css_with_default_span(&css_content);
+                    self.links.borrow_mut().extend(css_urls);
+                    self.style_content.borrow_mut().clear();
+                }
+            }
+        }
+
         // Check if this is a verbatim element, which we want to skip.
         if !self.include_verbatim && is_verbatim_elem(&name) {
             // Check if we're currently inside a verbatim block
diff --git a/lychee-lib/src/extract/html/html5gum.rs b/lychee-lib/src/extract/html/html5gum.rs
index c7b58c135f..f33741b62e 100644
--- a/lychee-lib/src/extract/html/html5gum.rs
+++ b/lychee-lib/src/extract/html/html5gum.rs
@@ -6,7 +6,7 @@ use std::collections::{HashMap, HashSet};
 
 use super::{is_email_link, is_verbatim_elem, srcset};
 use crate::{
-    extract::plaintext::extract_raw_uri_from_plaintext,
+    extract::{css::extract_css, plaintext::extract_raw_uri_from_plaintext},
     types::uri::raw::{OffsetSpanProvider, RawUri, SourceSpanProvider, SpanProvider},
 };
 
@@ -47,6 +47,12 @@ struct LinkExtractor<S: SpanProvider> {
     /// Element name of the current verbatim block.
     /// Used to keep track of nested verbatim blocks.
     verbatim_stack: Vec<String>,
+    /// Whether we're currently inside a `<style>` tag.
+    in_style_tag: bool,
+    /// Accumulated CSS content from within a `<style>` tag.
+    style_content: String,
+    /// Start offset of the style tag content (for span calculation).
+    style_content_offset: usize,
 }
 
 impl<S: SpanProvider> LinkExtractor<S> {
@@ -64,6 +70,9 @@ impl<S: SpanProvider> LinkExtractor<S> {
             current_attributes: HashMap::default(),
             current_attribute_name: String::default(),
             verbatim_stack: Vec::default(),
+            in_style_tag: false,
+            style_content: String::default(),
+            style_content_offset: 0,
         }
     }
 
@@ -119,6 +128,8 @@ impl<S: SpanProvider> LinkExtractor<S> {
         urls
     }
 
+    /// Check if we should filter out links in the current context due to being
+    /// inside a verbatim element.
     fn filter_verbatim_here(&self) -> bool {
         !self.include_verbatim
             && (is_verbatim_elem(&self.current_element) || !self.verbatim_stack.is_empty())
@@ -242,6 +253,12 @@ impl<S: SpanProvider> Callback<(), usize> for &mut LinkExtractor<S> {
             CallbackEvent::OpenStartTag { name } => {
                 self.current_element = String::from_utf8_lossy(name).into_owned();
 
+                // Check if we're entering a style tag
+                if self.current_element == "style" {
+                    self.in_style_tag = true;
+                    self.style_content.clear();
+                }
+
                 // Update the current verbatim element name.
                 //
                 // Keeps track of the last verbatim element name, so that we can
@@ -280,6 +297,21 @@ impl<S: SpanProvider> Callback<(), usize> for &mut LinkExtractor<S> {
             }
             CallbackEvent::EndTag { name } => {
                 let tag_name = String::from_utf8_lossy(name);
+
+                // Extract CSS URLs when closing a style tag
+                if tag_name == "style" && self.in_style_tag {
+                    self.in_style_tag = false;
+                    let css_urls = extract_css(
+                        &self.style_content,
+                        &OffsetSpanProvider {
+                            offset: self.style_content_offset,
+                            inner: &self.span_provider,
+                        },
+                    );
+                    self.links.extend(css_urls);
+                    self.style_content.clear();
+                }
+
                 // Update the current verbatim element name.
                 //
                 // Keeps track of the last verbatim element name, so that we can
@@ -292,6 +324,16 @@ impl<S: SpanProvider> Callback<(), usize> for &mut LinkExtractor<S> {
                 }
             }
             CallbackEvent::String { value } => {
+                // If we're inside a style tag, accumulate the CSS content
+                if self.in_style_tag {
+                    if self.style_content.is_empty() {
+                        // Record the start offset of the style content
+                        self.style_content_offset = span.start;
+                    }
+                    self.style_content.push_str(&String::from_utf8_lossy(value));
+                    return None;
+                }
+
                 if !self.filter_verbatim_here() {
                     // Extract links from the current string and add them to the links vector.
                     self.links.extend(extract_raw_uri_from_plaintext(
diff --git a/lychee-lib/src/extract/mod.rs b/lychee-lib/src/extract/mod.rs
index 282e8ae115..818147de25 100644
--- a/lychee-lib/src/extract/mod.rs
+++ b/lychee-lib/src/extract/mod.rs
@@ -3,10 +3,12 @@ use crate::types::{
     uri::raw::{RawUri, SourceSpanProvider},
 };
 
+pub mod css;
 pub mod html;
 pub mod markdown;
 mod plaintext;
 
+use css::extract_css;
 use markdown::extract_markdown;
 use plaintext::extract_raw_uri_from_plaintext;
 
@@ -43,7 +45,7 @@ impl Extractor {
     }
 
     /// Main entrypoint for extracting links from various sources
-    /// (Markdown, HTML, and plaintext)
+    /// (Markdown, HTML, CSS, and plaintext)
     #[must_use]
     pub fn extract(&self, input_content: &InputContent) -> Vec<RawUri> {
         match input_content.file_type {
@@ -59,6 +61,10 @@ impl Extractor {
                     html::html5gum::extract_html(&input_content.content, self.include_verbatim)
                 }
             }
+            FileType::Css => extract_css(
+                &input_content.content,
+                &SourceSpanProvider::from_input(&input_content.content),
+            ),
             FileType::Plaintext => extract_raw_uri_from_plaintext(
                 &input_content.content,
                 &SourceSpanProvider::from_input(&input_content.content),
@@ -77,7 +83,10 @@ mod tests {
     use super::*;
     use crate::{
         Uri,
-        types::{FileType, InputContent, ResolvedInputSource},
+        types::{
+            FileType, InputContent, ResolvedInputSource,
+            uri::raw::{RawUriSpan, span},
+        },
         utils::url::find_links,
     };
 
@@ -332,4 +341,80 @@ mod tests {
 
         assert_eq!(links, expected_links);
     }
+
+    #[test]
+    fn test_extract_css_from_style_tag() {
+        // Test case from issue #1485
+        let input = r#"<html>
+   <head>
+      <style>
+         div {
+             background-image: url("./lychee.png");
+         }
+      </style>
+   </head>
+</html>"#;
+        let input_content = InputContent::from_string(input, FileType::Html);
+        let extractor = Extractor::new(false, false, false);
+        let raw_uris = extractor.extract(&input_content);
+        assert_eq!(raw_uris, vec![css_url("./lychee.png", span(5, 32))]);
+    }
+
+    #[test]
+    fn test_extract_css_from_css_file() {
+        let input = r#"
+.example {
+    background-image: url("./image.png");
+    background: url('/absolute/path.jpg');
+}
+@import url(https://example.com/style.css);
+"#;
+        let input_content = InputContent::from_string(input, FileType::Css);
+        let extractor = Extractor::new(false, false, false);
+        let raw_uris = extractor.extract(&input_content);
+        assert_eq!(
+            raw_uris,
+            vec![
+                css_url("./image.png", span(3, 23)),
+                css_url("/absolute/path.jpg", span(4, 17)),
+                css_url("https://example.com/style.css", span(6, 9)),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_extract_multiple_css_urls_from_style_tag() {
+        let input = r#"<html>
+   <head>
+      <style>
+         .background {
+             background-image: url("./bg.png");
+         }
+         @font-face {
+             src: url(../fonts/font.woff2);
+         }
+      </style>
+   </head>
+</html>"#;
+        let input_content = InputContent::from_string(input, FileType::Html);
+        let extractor = Extractor::new(false, false, false);
+        let raw_uris = extractor.extract(&input_content);
+
+        assert_eq!(
+            raw_uris,
+            vec![
+                css_url("./bg.png", span(5, 32)),
+                css_url("../fonts/font.woff2", span(8, 19)),
+            ]
+        );
+    }
+
+    fn css_url(text: &str, span: RawUriSpan) -> RawUri {
+        RawUri {
+            text: text.into(),
+            element: Some("style".into()),
+            attribute: Some("url".into()),
+            span,
+        }
+    }
 }
diff --git a/lychee-lib/src/types/file.rs b/lychee-lib/src/types/file.rs
index 653f7323bd..29f01c021b 100644
--- a/lychee-lib/src/types/file.rs
+++ b/lychee-lib/src/types/file.rs
@@ -81,6 +81,7 @@ impl From<FileType> for FileExtensions {
         match file_type {
             FileType::Html => FileType::html_extensions(),
             FileType::Markdown => FileType::markdown_extensions(),
+            FileType::Css => FileType::css_extensions(),
             FileType::Plaintext => FileType::plaintext_extensions(),
         }
     }
@@ -115,11 +116,24 @@ pub enum FileType {
     Html,
     /// File in Markdown format
     Markdown,
+    /// File in CSS format
+    Css,
     /// Generic text file without syntax-specific parsing
     #[default]
     Plaintext,
 }
 
+impl std::fmt::Display for FileType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FileType::Html => write!(f, "HTML"),
+            FileType::Markdown => write!(f, "Markdown"),
+            FileType::Css => write!(f, "CSS"),
+            FileType::Plaintext => write!(f, "plaintext"),
+        }
+    }
+}
+
 impl FileType {
     /// All known Markdown extensions
     const MARKDOWN_EXTENSIONS: &'static [&'static str] = &[
@@ -129,6 +143,9 @@ impl FileType {
     /// All known HTML extensions
     const HTML_EXTENSIONS: &'static [&'static str] = &["htm", "html"];
 
+    /// All known CSS extensions
+    const CSS_EXTENSIONS: &'static [&'static str] = &["css"];
+
     /// All known plaintext extensions
     const PLAINTEXT_EXTENSIONS: &'static [&'static str] = &["txt"];
 
@@ -138,6 +155,7 @@ impl FileType {
         let mut extensions = FileExtensions::empty();
         extensions.extend(Self::markdown_extensions());
         extensions.extend(Self::html_extensions());
+        extensions.extend(Self::css_extensions());
         extensions.extend(Self::plaintext_extensions());
         extensions
     }
@@ -160,6 +178,15 @@ impl FileType {
             .collect()
     }
 
+    /// All known CSS extensions
+    #[must_use]
+    pub fn css_extensions() -> FileExtensions {
+        Self::CSS_EXTENSIONS
+            .iter()
+            .map(|&s| s.to_string())
+            .collect()
+    }
+
     /// All known plaintext extensions
     #[must_use]
     pub fn plaintext_extensions() -> FileExtensions {
@@ -177,6 +204,8 @@ impl FileType {
             Some(Self::Markdown)
         } else if Self::HTML_EXTENSIONS.contains(&ext.as_str()) {
             Some(Self::Html)
+        } else if Self::CSS_EXTENSIONS.contains(&ext.as_str()) {
+            Some(Self::Css)
         } else if Self::PLAINTEXT_EXTENSIONS.contains(&ext.as_str()) {
             Some(Self::Plaintext)
         } else {
@@ -240,12 +269,14 @@ mod tests {
         assert!(extensions.contains("html"));
         assert!(extensions.contains("markdown"));
         assert!(extensions.contains("htm"));
+        assert!(extensions.contains("css"));
         // Test that the count matches our static arrays
         let all_extensions: Vec<_> = extensions.into();
         assert_eq!(
             all_extensions.len(),
             FileType::MARKDOWN_EXTENSIONS.len()
                 + FileType::HTML_EXTENSIONS.len()
+                + FileType::CSS_EXTENSIONS.len()
                 + FileType::PLAINTEXT_EXTENSIONS.len()
         );
     }
diff --git a/lychee-lib/src/utils/fragment_checker.rs b/lychee-lib/src/utils/fragment_checker.rs
index 8c7fac6cd5..b737e1c804 100644
--- a/lychee-lib/src/utils/fragment_checker.rs
+++ b/lychee-lib/src/utils/fragment_checker.rs
@@ -131,8 +131,8 @@ impl FragmentChecker {
         let extractor = match file_type {
             FileType::Markdown => extract_markdown_fragments,
             FileType::Html => extract_html_fragments,
-            FileType::Plaintext => {
-                info!("Skipping fragment check for {url} within a plaintext file");
+            FileType::Css | FileType::Plaintext => {
+                info!("Skipping fragment check for {url} within a {file_type} file");
                 return Ok(true);
             }
         };