diff --git a/lib/css_inline.ex b/lib/css_inline.ex
index 4202f90..69aecef 100644
--- a/lib/css_inline.ex
+++ b/lib/css_inline.ex
@@ -21,6 +21,17 @@ defmodule CSSInline do
       iex> result =~ "color"
       true
 
+  ## Options
+
+  The following options can be passed to `inline/2` and `inline!/2`:
+
+    * `:inline_style_tags` - Whether to inline CSS from `<style>` tags. Defaults to `true`.
+    * `:keep_style_tags` - Whether to keep `<style>` tags after inlining. Defaults to `false`.
+    * `:keep_link_tags` - Whether to keep `<link>` tags after processing. Defaults to `false`.
+    * `:load_remote_stylesheets` - Whether to load remote stylesheets referenced in `<link>` tags.
+      Defaults to `true`. Set to `false` to skip external stylesheets.
+    * `:minify_css` - Whether to minify the inlined CSS. Defaults to `true`.
+
   ## Performance
 
   The Rust NIF runs on a dirty CPU scheduler to avoid blocking the BEAM's main schedulers,
@@ -28,14 +39,50 @@ defmodule CSSInline do
   uses zero-copy input handling and direct buffer writes for optimal performance.
   """
 
+  defmodule Options do
+    @moduledoc """
+    Options struct for CSS inlining configuration.
+    """
+    defstruct inline_style_tags: true,
+              keep_style_tags: false,
+              keep_link_tags: false,
+              load_remote_stylesheets: true,
+              minify_css: true
+
+    @type t :: %__MODULE__{
+            inline_style_tags: boolean(),
+            keep_style_tags: boolean(),
+            keep_link_tags: boolean(),
+            load_remote_stylesheets: boolean(),
+            minify_css: boolean()
+          }
+  end
+
+  @type option ::
+          {:inline_style_tags, boolean()}
+          | {:keep_style_tags, boolean()}
+          | {:keep_link_tags, boolean()}
+          | {:load_remote_stylesheets, boolean()}
+          | {:minify_css, boolean()}
+
   @doc """
   Inlines CSS from `<style>` tags into element `style` attributes.
 
   Returns `{:ok, inlined_html}` on success, or `{:error, reason}` on failure.
+
+  ## Options
+
+    * `:inline_style_tags` - Whether to inline CSS from `<style>` tags. Defaults to `true`.
+    * `:keep_style_tags` - Whether to keep `<style>` tags after inlining. Defaults to `false`.
+    * `:keep_link_tags` - Whether to keep `<link>` tags after processing. Defaults to `false`.
+    * `:load_remote_stylesheets` - Whether to load remote stylesheets. Defaults to `true`.
+    * `:minify_css` - Whether to minify the inlined CSS. Defaults to `true`.
   """
-  @spec inline(String.t()) :: {:ok, String.t()} | {:error, term()}
-  def inline(html) when is_binary(html) do
-    case CSSInline.Native.inline_css(html) do
+  @spec inline(String.t(), [option()]) :: {:ok, String.t()} | {:error, term()}
+  def inline(html, opts \\ []) when is_binary(html) and is_list(opts) do
+    options = struct(Options, opts)
+
+    case CSSInline.Native.inline_css(html, options) do
       result when is_binary(result) or is_list(result) ->
         {:ok, IO.iodata_to_binary(result)}
 
@@ -50,10 +97,18 @@ defmodule CSSInline do
   Inlines CSS from `<style>` tags into element `style` attributes.
 
   Returns the inlined HTML on success, or raises an exception on failure.
+
+  ## Options
+
+    * `:inline_style_tags` - Whether to inline CSS from `<style>` tags. Defaults to `true`.
+    * `:keep_style_tags` - Whether to keep `<style>` tags after inlining. Defaults to `false`.
+    * `:keep_link_tags` - Whether to keep `<link>` tags after processing. Defaults to `false`.
+    * `:load_remote_stylesheets` - Whether to load remote stylesheets. Defaults to `true`.
+    * `:minify_css` - Whether to minify the inlined CSS. Defaults to `true`.
   """
-  @spec inline!(String.t()) :: String.t()
-  def inline!(html) when is_binary(html) do
-    case inline(html) do
+  @spec inline!(String.t(), [option()]) :: String.t()
+  def inline!(html, opts \\ []) when is_binary(html) and is_list(opts) do
+    case inline(html, opts) do
       {:ok, result} -> result
       {:error, reason} -> raise "CSS inlining failed: #{inspect(reason)}"
     end
diff --git a/lib/css_inline/native.ex b/lib/css_inline/native.ex
index db7759d..f612cf8 100644
--- a/lib/css_inline/native.ex
+++ b/lib/css_inline/native.ex
@@ -20,5 +20,5 @@ defmodule CSSInline.Native do
 
   # NIF function - will be replaced at runtime by the Rust implementation.
   # This stub is only used if the NIF fails to load.
-  def inline_css(_html), do: :erlang.nif_error(:nif_not_loaded)
+  def inline_css(_html, _opts), do: :erlang.nif_error(:nif_not_loaded)
 end
diff --git a/mix.exs b/mix.exs
index 1511cfb..88e035d 100644
--- a/mix.exs
+++ b/mix.exs
@@ -1,7 +1,7 @@
 defmodule CSSInline.MixProject do
   use Mix.Project
 
-  @version "0.1.1"
+  @version "0.1.2"
 
   def project do
     [
diff --git a/native/css_inline_nif/Cargo.lock b/native/css_inline_nif/Cargo.lock
index 324190d..97e98fc 100644
--- a/native/css_inline_nif/Cargo.lock
+++ b/native/css_inline_nif/Cargo.lock
@@ -87,9 +87,9 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "css-inline"
-version = "0.19.0"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a6803e80ade2d53b280935cbaf6f124c38c26aeb6cae3c276123bdd13aeb3a8"
+checksum = "ff246a3af11c7b3747663a5d96c991425ee75abc60ef2cbf32d61d1762196c12"
 dependencies = [
  "cssparser",
  "html5ever",
@@ -220,16 +220,6 @@ dependencies = [
  "percent-encoding",
 ]
 
-[[package]]
-name = "futf"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df420e2e84819663797d1ec6544b13c5be84629e7bb00dc960d6917db2987843"
-dependencies = [
- "mac",
- "new_debug_unreachable",
-]
-
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -326,9 +316,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "html5ever"
-version = "0.36.1"
+version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6452c4751a24e1b99c3260d505eaeee76a050573e61f30ac2c924ddc7236f01e"
+checksum = "1054432bae2f14e0061e33d23402fbaa67a921d319d56adc6bcf887ddad1cbc2"
 dependencies = [
  "log",
  "markup5ever",
@@ -630,17 +620,11 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
 
-[[package]]
-name = "mac"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
-
 [[package]]
 name = "markup5ever"
-version = "0.36.1"
+version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c3294c4d74d0742910f8c7b466f44dda9eb2d5742c1e430138df290a1e8451c"
+checksum = "8983d30f2915feeaaab2d6babdd6bc7e9ed1a00b66b5e6d74df19aa9c0e91862"
 dependencies = [
  "log",
  "tendril",
@@ -1086,9 +1070,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "selectors"
-version = "0.33.0"
+version = "0.35.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "feef350c36147532e1b79ea5c1f3791373e61cbd9a6a2615413b3807bb164fb7"
+checksum = "93fdfed56cd634f04fe8b9ddf947ae3dc493483e819593d2ba17df9ad05db8b2"
 dependencies = [
  "bitflags",
  "cssparser",
@@ -1276,12 +1260,11 @@ dependencies = [
 
 [[package]]
 name = "tendril"
-version = "0.4.3"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d24a120c5fc464a3458240ee02c299ebcb9d67b5249c8848b09d639dca8d7bb0"
+checksum = "c4790fc369d5a530f4b544b094e31388b9b3a37c0f4652ade4505945f5660d24"
 dependencies = [
- "futf",
- "mac",
+ "new_debug_unreachable",
  "utf-8",
 ]
 
diff --git a/native/css_inline_nif/Cargo.toml b/native/css_inline_nif/Cargo.toml
index 449aab6..ade25c5 100644
--- a/native/css_inline_nif/Cargo.toml
+++ b/native/css_inline_nif/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "css_inline_nif"
-version = "0.1.0"
+version = "0.1.2"
 edition = "2021"
 authors = ["Knock Labs"]
 publish = false
@@ -17,4 +17,4 @@ nif_version_2_17 = ["rustler/nif_version_2_17"]
 
 [dependencies]
 rustler = "0.37"
-css-inline = "0.19"
+css-inline = "0.19.1"
diff --git a/native/css_inline_nif/src/lib.rs b/native/css_inline_nif/src/lib.rs
index 96ffab3..d3e7ca6 100644
--- a/native/css_inline_nif/src/lib.rs
+++ b/native/css_inline_nif/src/lib.rs
@@ -1,5 +1,16 @@
 use css_inline::CSSInliner;
-use rustler::Error as RustlerError;
+use rustler::{Error as RustlerError, NifStruct};
+
+/// Options for CSS inlining, mapped from Elixir struct.
+#[derive(Debug, NifStruct)]
+#[module = "CSSInline.Options"]
+struct Options {
+    inline_style_tags: bool,
+    keep_style_tags: bool,
+    keep_link_tags: bool,
+    load_remote_stylesheets: bool,
+    minify_css: bool,
+}
 
 /// Inlines CSS from `<style>` tags into element `style` attributes.
 ///
@@ -21,10 +32,16 @@ use rustler::Error as RustlerError;
 /// - **Output copy**: The final copy from Rust heap to BEAM heap is unavoidable
 ///   since BEAM-managed data must live on the BEAM heap.
 #[rustler::nif(schedule = "DirtyCpu")]
-fn inline_css(html: &str) -> Result<Vec<u8>, RustlerError> {
+fn inline_css(html: &str, opts: Options) -> Result<Vec<u8>, RustlerError> {
     let estimated_size = (html.len() as f64 * 1.5) as usize;
     let mut buffer: Vec<u8> = Vec::with_capacity(estimated_size);
-    let inliner = CSSInliner::options().minify_css(true).build();
+    let inliner = CSSInliner::options()
+        .inline_style_tags(opts.inline_style_tags)
+        .keep_style_tags(opts.keep_style_tags)
+        .keep_link_tags(opts.keep_link_tags)
+        .load_remote_stylesheets(opts.load_remote_stylesheets)
+        .minify_css(opts.minify_css)
+        .build();
 
     inliner
         .inline_to(html, &mut buffer)
diff --git a/test/css_inline_test.exs b/test/css_inline_test.exs
index 3017263..6b37863 100644
--- a/test/css_inline_test.exs
+++ b/test/css_inline_test.exs
@@ -84,7 +84,116 @@ defmodule CSSInlineTest do
     end
   end
 
-  describe "inline!/1" do
+  describe "inline/2 with options" do
+    test "keep_style_tags: true preserves style tags" do
+      html = """
+      <html>
+        <head>
+          <style>p { color: red; }</style>
+        </head>
+        <body><p>Hello</p></body>
+      </html>
+      """
+
+      assert {:ok, result} = CSSInline.inline(html, keep_style_tags: true)
+      assert result =~ "<style>"
+      assert result =~ ~r/<p[^>]*style="[^"]*color: ?red/
+    end
+
+    test "keep_style_tags: false removes style tags (default)" do
+      html = """
+      <html>
+        <head>
+          <style>p { color: red; }</style>
+        </head>
+        <body><p>Hello</p></body>
+      </html>
+      """
+
+      assert {:ok, result} = CSSInline.inline(html, keep_style_tags: false)
+      refute result =~ "<style>"
+    end
+
+    test "inline_style_tags: false skips inlining from style tags" do
+      html = """
+      <html>
+        <head>
+          <style>p { color: red; }</style>
+        </head>
+        <body><p>Hello</p></body>
+      </html>
+      """
+
+      assert {:ok, result} = CSSInline.inline(html, inline_style_tags: false)
+      # The style should NOT be inlined
+      refute result =~ ~r/<p[^>]*style=/
+    end
+
+    test "minify_css: false preserves whitespace in CSS" do
+      html = """
+      <html>
+        <head>
+          <style>p { color: red; margin: 10px; }</style>
+        </head>
+        <body><p>Hello</p></body>
+      </html>
+      """
+
+      assert {:ok, result} = CSSInline.inline(html, minify_css: false)
+      # With minify_css: false, there should be spaces around colons
+      assert result =~ "color: red"
+    end
+
+    test "keep_link_tags: true preserves link tags" do
+      html = """
+      <html>
+        <head>
+          <link rel="stylesheet" href="https://example.com/style.css">
+          <style>p { color: red; }</style>
+        </head>
+        <body><p>Hello</p></body>
+      </html>
+      """
+
+      assert {:ok, result} =
+               CSSInline.inline(html, keep_link_tags: true, load_remote_stylesheets: false)
+
+      assert result =~ "<link"
+    end
+
+    test "load_remote_stylesheets: false skips external stylesheets" do
+      html = """
+      <html>
+        <head>
+          <link rel="stylesheet" href="https://example.com/nonexistent.css">
+          <style>p { color: red; }</style>
+        </head>
+        <body><p>Hello</p></body>
+      </html>
+      """
+
+      # With load_remote_stylesheets: false, this should succeed without trying to fetch
+      assert {:ok, result} = CSSInline.inline(html, load_remote_stylesheets: false)
+      assert result =~ ~r/<p[^>]*style="[^"]*color: ?red/
+    end
+
+    test "multiple options can be combined" do
+      html = """
+      <html>
+        <head>
+          <style>p { color: red; }</style>
+        </head>
+        <body><p>Hello</p></body>
+      </html>
+      """
+
+      assert {:ok, result} = CSSInline.inline(html, keep_style_tags: true, minify_css: false)
+      assert result =~ "<style>"
+      assert result =~ "color: red"
+    end
+  end
+
+  describe "inline!/2 with options" do
     test "returns inlined HTML on success" do
       html = """
       <html>
@@ -99,6 +208,20 @@ defmodule CSSInlineTest do
       assert result =~ ~r/<p[^>]*style="[^"]*color: ?blue/
     end
 
+    test "accepts options" do
+      html = """
+      <html>
+        <head>
+          <style>p { color: blue; }</style>
+        </head>
+        <body><p>Hello</p></body>
+      </html>
+      """
+
+      result = CSSInline.inline!(html, keep_style_tags: true)
+      assert result =~ "<style>"
+    end
+
     test "raises on error" do
       html = """
       <html>