diff --git a/docs/features.md b/docs/features.md
index 4f60c411..551f30d0 100644
--- a/docs/features.md
+++ b/docs/features.md
@@ -37,7 +37,10 @@ This tool targets the current latest public release for macOS and iMessage. It m
 - Attachments
   - Any type of attachment that can be displayed on the web is embedded in the HTML exports
   - Attachments can be copied to the export directory or referenced in-place
-  - Less-compatible HEIC images are converted to PNG for portable exports
+  - Less-compatible images are converted for portable exports:
+    - Attachment `HEIC` files convert to `JPEG`
+    - Sticker `HEIC` files convert to `PNG`
+    - Sticker `HEICS` files convert to `GIF`
   - Attachments are displayed as
     - File paths in TXT exports
     - Embeds in HTML exports (including `<img>`, `<video>`, and `<audio>`)
diff --git a/imessage-database/src/error/attachment.rs b/imessage-database/src/error/attachment.rs
new file mode 100644
index 00000000..1d1fe044
--- /dev/null
+++ b/imessage-database/src/error/attachment.rs
@@ -0,0 +1,28 @@
+/*!
+ Errors that can happen when parsing message data
+*/
+
+use std::{
+    fmt::{Display, Formatter, Result},
+    io::Error,
+};
+
+/// Errors that can happen when working with attachment table data
+#[derive(Debug)]
+pub enum AttachmentError {
+    FileNotFound(String),
+    Unreadable(String, Error),
+}
+
+impl Display for AttachmentError {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+        match self {
+            AttachmentError::FileNotFound(path) => {
+                write!(fmt, "File not found at location: {path}")
+            }
+            AttachmentError::Unreadable(path, why) => {
+                write!(fmt, "Unable to read file at {path}: {why}")
+            }
+        }
+    }
+}
diff --git a/imessage-database/src/error/mod.rs b/imessage-database/src/error/mod.rs
index 73019f47..86fa718c 100644
--- a/imessage-database/src/error/mod.rs
+++ b/imessage-database/src/error/mod.rs
@@ -2,6 +2,7 @@
  This module contains types of errors that can happen when parsing iMessage data.
 */
 
+pub mod attachment;
 pub mod message;
 pub mod plist;
 pub mod query_context;
diff --git a/imessage-database/src/message_types/mod.rs b/imessage-database/src/message_types/mod.rs
index 84963db7..a3663c2f 100644
--- a/imessage-database/src/message_types/mod.rs
+++ b/imessage-database/src/message_types/mod.rs
@@ -3,9 +3,10 @@
 */
 
 pub mod app;
+pub mod collaboration;
 pub mod edited;
 pub mod expressives;
 pub mod music;
+pub mod sticker;
 pub mod url;
 pub mod variants;
-pub mod collaboration;
diff --git a/imessage-database/src/message_types/sticker.rs b/imessage-database/src/message_types/sticker.rs
new file mode 100644
index 00000000..3738408b
--- /dev/null
+++ b/imessage-database/src/message_types/sticker.rs
@@ -0,0 +1,168 @@
+use std::fmt::Display;
+
+/// Bytes for `stickerEffect:type="`
+const STICKER_EFFECT_PREFIX: [u8; 20] = [
+    115, 116, 105, 99, 107, 101, 114, 69, 102, 102, 101, 99, 116, 58, 116, 121, 112, 101, 61, 34,
+];
+/// Bytes for `"/>`
+const STICKER_EFFECT_SUFFIX: [u8; 3] = [34, 47, 62];
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum StickerEffect {
+    /// Sticker sent with no effect
+    Normal,
+    /// Internally referred to as `stroke`
+    Outline,
+    Comic,
+    Puffy,
+    /// Internally referred to as `iridescent`
+    Shiny,
+    Other(String),
+}
+
+impl StickerEffect {
+    pub fn from_exif(sticker_effect_type: &str) -> Self {
+        match sticker_effect_type {
+            "stroke" => Self::Outline,
+            "comic" => Self::Comic,
+            "puffy" => Self::Puffy,
+            "iridescent" => Self::Shiny,
+            other => Self::Other(other.to_owned()),
+        }
+    }
+}
+
+impl Display for StickerEffect {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StickerEffect::Normal => write!(fmt, "Normal"),
+            StickerEffect::Outline => write!(fmt, "Outline"),
+            StickerEffect::Comic => write!(fmt, "Comic"),
+            StickerEffect::Puffy => write!(fmt, "Puffy"),
+            StickerEffect::Shiny => write!(fmt, "Shiny"),
+            StickerEffect::Other(name) => write!(fmt, "{name}"),
+        }
+    }
+}
+
+impl Default for StickerEffect {
+    fn default() -> Self {
+        Self::Normal
+    }
+}
+
+/// Parse the sticker effect type from the EXIF data of a HEIC blob
+pub fn get_sticker_effect(mut heic_data: Vec<u8>) -> StickerEffect {
+    // Find the start index and drain
+    for idx in 0..heic_data.len() {
+        if idx + STICKER_EFFECT_PREFIX.len() < heic_data.len() {
+            let part = &heic_data[idx..idx + STICKER_EFFECT_PREFIX.len()];
+            if part == STICKER_EFFECT_PREFIX {
+                // Remove the start pattern from the blob
+                heic_data.drain(..idx + STICKER_EFFECT_PREFIX.len());
+                break;
+            }
+        } else {
+            return StickerEffect::Normal;
+        }
+    }
+
+    // Find the end index and truncate
+    for idx in 1..heic_data.len() {
+        if idx >= heic_data.len() - 2 {
+            return StickerEffect::Other("Unknown".to_string());
+        }
+        let part = &heic_data[idx..idx + STICKER_EFFECT_SUFFIX.len()];
+
+        if part == STICKER_EFFECT_SUFFIX {
+            // Remove the end pattern from the string
+            heic_data.truncate(idx);
+            break;
+        }
+    }
+    StickerEffect::from_exif(&String::from_utf8_lossy(&heic_data))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::env::current_dir;
+    use std::fs::File;
+    use std::io::Read;
+
+    use crate::message_types::sticker::{get_sticker_effect, StickerEffect};
+
+    #[test]
+    fn test_parse_sticker_normal() {
+        let sticker_path = current_dir()
+            .unwrap()
+            .as_path()
+            .join("test_data/stickers/no_effect.heic");
+        let mut file = File::open(sticker_path).unwrap();
+        let mut bytes = vec![];
+        file.read_to_end(&mut bytes).unwrap();
+
+        let effect = get_sticker_effect(bytes);
+
+        assert_eq!(effect, StickerEffect::Normal);
+    }
+
+    #[test]
+    fn test_parse_sticker_outline() {
+        let sticker_path = current_dir()
+            .unwrap()
+            .as_path()
+            .join("test_data/stickers/outline.heic");
+        let mut file = File::open(sticker_path).unwrap();
+        let mut bytes = vec![];
+        file.read_to_end(&mut bytes).unwrap();
+
+        let effect = get_sticker_effect(bytes);
+
+        assert_eq!(effect, StickerEffect::Outline);
+    }
+
+    #[test]
+    fn test_parse_sticker_comic() {
+        let sticker_path = current_dir()
+            .unwrap()
+            .as_path()
+            .join("test_data/stickers/comic.heic");
+        let mut file = File::open(sticker_path).unwrap();
+        let mut bytes = vec![];
+        file.read_to_end(&mut bytes).unwrap();
+
+        let effect = get_sticker_effect(bytes);
+
+        assert_eq!(effect, StickerEffect::Comic);
+    }
+
+    #[test]
+    fn test_parse_sticker_puffy() {
+        let sticker_path = current_dir()
+            .unwrap()
+            .as_path()
+            .join("test_data/stickers/puffy.heic");
+        let mut file = File::open(sticker_path).unwrap();
+        let mut bytes = vec![];
+        file.read_to_end(&mut bytes).unwrap();
+
+        let effect = get_sticker_effect(bytes);
+
+        assert_eq!(effect, StickerEffect::Puffy);
+    }
+
+    #[test]
+    fn test_parse_sticker_shiny() {
+        let sticker_path = current_dir()
+            .unwrap()
+            .as_path()
+            .join("test_data/stickers/shiny.heic");
+        let mut file = File::open(sticker_path).unwrap();
+        let mut bytes = vec![];
+        file.read_to_end(&mut bytes).unwrap();
+
+        let effect = get_sticker_effect(bytes);
+
+        assert_eq!(effect, StickerEffect::Shiny);
+    }
+}
diff --git a/imessage-database/src/tables/attachment.rs b/imessage-database/src/tables/attachment.rs
index ddfc0a75..d071239a 100644
--- a/imessage-database/src/tables/attachment.rs
+++ b/imessage-database/src/tables/attachment.rs
@@ -4,10 +4,15 @@
 
 use rusqlite::{Connection, Error, Result, Row, Statement};
 use sha1::{Digest, Sha1};
-use std::path::{Path, PathBuf};
+use std::{
+    fs::File,
+    io::Read,
+    path::{Path, PathBuf},
+};
 
 use crate::{
-    error::table::TableError,
+    error::{attachment::AttachmentError, table::TableError},
+    message_types::sticker::{get_sticker_effect, StickerEffect},
     tables::{
         messages::Message,
         table::{Table, ATTACHMENT},
@@ -45,6 +50,7 @@ pub struct Attachment {
     pub mime_type: Option<String>,
     pub transfer_name: Option<String>,
     pub total_bytes: i64,
+    pub is_sticker: bool,
     pub hide_attachment: i32,
     pub copied_path: Option<PathBuf>,
 }
@@ -58,6 +64,7 @@ impl Table for Attachment {
             mime_type: row.get("mime_type").unwrap_or(None),
             transfer_name: row.get("transfer_name").unwrap_or(None),
             total_bytes: row.get("total_bytes").unwrap_or_default(),
+            is_sticker: row.get("is_sticker").unwrap_or(false),
             hide_attachment: row.get("hide_attachment").unwrap_or(0),
             copied_path: None,
         })
@@ -137,6 +144,41 @@ impl Attachment {
         }
     }
 
+    pub fn as_bytes(
+        &self,
+        platform: &Platform,
+        db_path: &Path,
+    ) -> Result<Option<Vec<u8>>, AttachmentError> {
+        if let Some(file_path) = self.resolved_attachment_path(platform, db_path) {
+            let mut file = File::open(&file_path)
+                .map_err(|err| AttachmentError::Unreadable(file_path, err))?;
+            let mut bytes = vec![];
+            file.read_to_end(&mut bytes).unwrap();
+
+            return Ok(Some(bytes));
+        }
+        Ok(None)
+    }
+
+    pub fn get_sticker_effect(
+        &self,
+        platform: &Platform,
+        db_path: &Path,
+    ) -> Result<Option<StickerEffect>, AttachmentError> {
+        // Handle the non-sticker case
+        if !self.is_sticker {
+            return Ok(None);
+        }
+
+        // Try to parse the HEIC data
+        if let Some(data) = self.as_bytes(platform, db_path)? {
+            return Ok(Some(get_sticker_effect(data)));
+        }
+
+        // Default if the attachment is a sticker and cannot be parsed/read
+        Ok(Some(StickerEffect::default()))
+    }
+
     /// Get the path to an attachment, if it exists
     pub fn path(&self) -> Option<&Path> {
         match &self.filename {
@@ -331,6 +373,7 @@ mod tests {
             mime_type: Some("image".to_string()),
             transfer_name: Some("c.png".to_string()),
             total_bytes: 100,
+            is_sticker: false,
             hide_attachment: 0,
             copied_path: None,
         }
diff --git a/imessage-database/test_data/stickers/comic.heic b/imessage-database/test_data/stickers/comic.heic
new file mode 100644
index 00000000..6ebbd663
Binary files /dev/null and b/imessage-database/test_data/stickers/comic.heic differ
diff --git a/imessage-database/test_data/stickers/no_effect.heic b/imessage-database/test_data/stickers/no_effect.heic
new file mode 100644
index 00000000..a3ef3327
Binary files /dev/null and b/imessage-database/test_data/stickers/no_effect.heic differ
diff --git a/imessage-database/test_data/stickers/outline.heic b/imessage-database/test_data/stickers/outline.heic
new file mode 100644
index 00000000..4ac56b43
Binary files /dev/null and b/imessage-database/test_data/stickers/outline.heic differ
diff --git a/imessage-database/test_data/stickers/puffy.heic b/imessage-database/test_data/stickers/puffy.heic
new file mode 100644
index 00000000..450422e7
Binary files /dev/null and b/imessage-database/test_data/stickers/puffy.heic differ
diff --git a/imessage-database/test_data/stickers/shiny.heic b/imessage-database/test_data/stickers/shiny.heic
new file mode 100644
index 00000000..2f2e91fb
Binary files /dev/null and b/imessage-database/test_data/stickers/shiny.heic differ
diff --git a/imessage-exporter/src/app/attachment_manager.rs b/imessage-exporter/src/app/attachment_manager.rs
index f8cd00bc..2fc00d86 100644
--- a/imessage-exporter/src/app/attachment_manager.rs
+++ b/imessage-exporter/src/app/attachment_manager.rs
@@ -9,7 +9,7 @@ use imessage_database::tables::{attachment::Attachment, messages::Message};
 use uuid::Uuid;
 
 use crate::app::{
-    converter::{heic_to_jpeg, Converter},
+    converter::{convert_heic, Converter, ImageType},
     runtime::Config,
 };
 
@@ -72,7 +72,7 @@ impl AttachmentManager {
             match self {
                 AttachmentManager::Compatible => match &config.converter {
                     Some(converter) => {
-                        Self::copy_convert(from, &mut to, converter);
+                        Self::copy_convert(from, &mut to, converter, attachment.is_sticker);
                     }
                     None => Self::copy_raw(from, &to),
                 },
@@ -116,12 +116,41 @@ impl AttachmentManager {
     }
 
     /// Copy a file, converting if possible
-    fn copy_convert(from: &Path, to: &mut PathBuf, converter: &Converter) {
-        let ext = from.extension().unwrap_or_default();
-        if ext == "heic" || ext == "HEIC" {
+    ///
+    /// - Sticker `HEIC` files convert to `PNG`
+    /// - Sticker `HEICS` files convert to `GIF`
+    /// - Attachment `HEIC` files convert to `JPEG`
+    /// - Other files are just copied with their original formats
+    fn copy_convert(from: &Path, to: &mut PathBuf, converter: &Converter, is_sticker: bool) {
+        let original_extension = from.extension().unwrap_or_default();
+
+        // Handle sticker attachments
+        if is_sticker {
+            // Determine the output type of the sticker
+            let output_type: Option<ImageType> = match original_extension.to_str() {
+                // Normal stickers get converted to png
+                Some("heic") | Some("HEIC") => Some(ImageType::Png),
+                // Animated stickers get converted to gif
+                Some("heics") | Some("HEICS") => Some(ImageType::Gif),
+                _ => None,
+            };
+
+            match output_type {
+                Some(output_type) => {
+                    to.set_extension(output_type.to_str());
+                    if convert_heic(from, to, converter, output_type).is_none() {
+                        eprintln!("Unable to convert {from:?}")
+                    }
+                }
+                None => Self::copy_raw(from, to),
+            }
+        }
+        // Normal attachments always get converted to jpeg
+        else if original_extension == "heic" || original_extension == "HEIC" {
+            let output_type = ImageType::Jpeg;
             // Update extension for conversion
-            to.set_extension("jpg");
-            if heic_to_jpeg(from, to, converter).is_none() {
+            to.set_extension(output_type.to_str());
+            if convert_heic(from, to, converter, output_type).is_none() {
                 eprintln!("Unable to convert {from:?}")
             }
         } else {
diff --git a/imessage-exporter/src/app/converter.rs b/imessage-exporter/src/app/converter.rs
index c063aad4..99f90532 100644
--- a/imessage-exporter/src/app/converter.rs
+++ b/imessage-exporter/src/app/converter.rs
@@ -4,6 +4,26 @@ use std::{
     process::{Command, Stdio},
 };
 
+#[derive(Debug)]
+pub enum ImageType {
+    #[allow(non_camel_case_types)]
+    Jpeg,
+    #[allow(non_camel_case_types)]
+    Gif,
+    #[allow(non_camel_case_types)]
+    Png,
+}
+
+impl ImageType {
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            ImageType::Jpeg => "jpeg",
+            ImageType::Gif => "gif",
+            ImageType::Png => "png",
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum Converter {
     Sips,
@@ -40,7 +60,7 @@ fn exists(name: &str) -> bool {
     false
 }
 
-/// Convert a HEIC image file to a JPEG
+/// Convert a HEIC image file to the provided format
 ///
 /// This uses the macOS builtin `sips` program
 /// Docs: <https://www.unix.com/man-page/osx/1/sips/> (or `man sips`)
@@ -49,7 +69,12 @@ fn exists(name: &str) -> bool {
 /// of failing, `sips` will create a file called `fake` in `/`. Subsequent writes
 /// by `sips` to the same location will not fail, but since it is a file instead
 /// of a directory, this will fail for non-`sips` copies.
-pub fn heic_to_jpeg(from: &Path, to: &Path, converter: &Converter) -> Option<()> {
+pub fn convert_heic(
+    from: &Path,
+    to: &Path,
+    converter: &Converter,
+    output_image_type: ImageType,
+) -> Option<()> {
     // Get the path we want to copy from
     let from_path = from.to_str()?;
 
@@ -70,7 +95,14 @@ pub fn heic_to_jpeg(from: &Path, to: &Path, converter: &Converter) -> Option<()>
         Converter::Sips => {
             // Build the command
             match Command::new("sips")
-                .args(&vec!["-s", "format", "jpeg", from_path, "-o", to_path])
+                .args(&vec![
+                    "-s",
+                    "format",
+                    output_image_type.to_str(),
+                    from_path,
+                    "-o",
+                    to_path,
+                ])
                 .stdout(Stdio::null())
                 .stderr(Stdio::null())
                 .stdin(Stdio::null())
diff --git a/imessage-exporter/src/app/runtime.rs b/imessage-exporter/src/app/runtime.rs
index b237c306..93837f55 100644
--- a/imessage-exporter/src/app/runtime.rs
+++ b/imessage-exporter/src/app/runtime.rs
@@ -797,6 +797,7 @@ mod directory_tests {
             mime_type: Some("image/png".to_string()),
             transfer_name: Some("d.jpg".to_string()),
             total_bytes: 100,
+            is_sticker: false,
             hide_attachment: 0,
             copied_path: None,
         }
diff --git a/imessage-exporter/src/exporters/exporter.rs b/imessage-exporter/src/exporters/exporter.rs
index 0ae8c11e..f26bf262 100644
--- a/imessage-exporter/src/exporters/exporter.rs
+++ b/imessage-exporter/src/exporters/exporter.rs
@@ -30,6 +30,8 @@ pub(super) trait Writer<'a> {
         attachment: &'a mut Attachment,
         msg: &'a Message,
     ) -> Result<String, &'a str>;
+    /// Format a sticker, possibly by reading the disk
+    fn format_sticker(&self, attachment: &'a mut Attachment, msg: &'a Message) -> String;
     /// Format an app message by parsing some of its fields
     fn format_app(
         &self,
diff --git a/imessage-exporter/src/exporters/html.rs b/imessage-exporter/src/exporters/html.rs
index 29446f0f..b283cc12 100644
--- a/imessage-exporter/src/exporters/html.rs
+++ b/imessage-exporter/src/exporters/html.rs
@@ -312,20 +312,37 @@ impl<'a> Writer<'a> for HTML<'a> {
                 }
                 BubbleType::Attachment => {
                     match attachments.get_mut(attachment_index) {
-                        Some(attachment) => match self.format_attachment(attachment, message) {
-                            Ok(result) => {
-                                attachment_index += 1;
-                                self.add_line(&mut formatted_message, &result, "", "");
-                            }
-                            Err(result) => {
+                        Some(attachment) => {
+                            if attachment.is_sticker {
+                                let result = self.format_sticker(attachment, message);
                                 self.add_line(
                                     &mut formatted_message,
-                                    result,
-                                    "<span class=\"attachment_error\">Unable to locate attachment: ",
-                                    "</span>",
-                                );
+                                    &result,
+                                    "<div class=\"sticker\">",
+                                    "</div>",
+                                )
+                            } else {
+                                match self.format_attachment(attachment, message) {
+                                    Ok(result) => {
+                                        attachment_index += 1;
+                                        self.add_line(
+                                            &mut formatted_message,
+                                            &result,
+                                            "<div class=\"attachment\">",
+                                            "</div>",
+                                        );
+                                    }
+                                    Err(result) => {
+                                        self.add_line(
+                                        &mut formatted_message,
+                                        result,
+                                        "<span class=\"attachment_error\">Unable to locate attachment: ",
+                                        "</span>",
+                                    );
+                                    }
+                                }
                             }
-                        },
+                        }
                         // Attachment does not exist in attachments table
                         None => self.add_line(
                             &mut formatted_message,
@@ -489,6 +506,22 @@ impl<'a> Writer<'a> for HTML<'a> {
         });
     }
 
+    fn format_sticker(&self, sticker: &'a mut Attachment, message: &Message) -> String {
+        match self.format_attachment(sticker, message) {
+            Ok(sticker_embed) => {
+                let sticker_effect = sticker.get_sticker_effect(
+                    &self.config.options.platform,
+                    &self.config.options.db_path,
+                );
+                if let Ok(Some(sticker_effect)) = sticker_effect {
+                    return format!("{sticker_embed}\n<div class=\"sticker_effect\">Sent with {sticker_effect} effect</div>");
+                }
+                sticker_embed
+            }
+            Err(embed) => embed.to_string(),
+        }
+    }
+
     fn format_app(
         &self,
         message: &'a Message,
@@ -581,17 +614,11 @@ impl<'a> Writer<'a> for HTML<'a> {
                 let who = self.config.who(&msg.handle_id, msg.is_from_me);
                 // Sticker messages have only one attachment, the sticker image
                 Ok(match paths.get_mut(0) {
-                    Some(sticker) => match self.format_attachment(sticker, msg) {
-                        Ok(img) => {
-                            Some(format!("{img}<span class=\"reaction\"> from {who}</span>"))
-                        }
-                        Err(_) => None,
-                    },
-                    None => None,
-                }
-                .unwrap_or_else(|| {
-                    format!("<span class=\"reaction\">Sticker from {who} not found!</span>")
-                }))
+                    Some(sticker) => self.format_sticker(sticker, msg),
+                    None => {
+                        format!("<span class=\"reaction\">Sticker from {who} not found!</span>")
+                    }
+                })
             }
             _ => unreachable!(),
         }
@@ -606,7 +633,7 @@ impl<'a> Writer<'a> for HTML<'a> {
                 ScreenEffect::Balloons => "Sent with Balloons",
                 ScreenEffect::Heart => "Sent with Heart",
                 ScreenEffect::Lasers => "Sent with Lasers",
-                ScreenEffect::ShootingStar => "Sent with Shooting Start",
+                ScreenEffect::ShootingStar => "Sent with Shooting Star",
                 ScreenEffect::Sparkles => "Sent with Sparkles",
                 ScreenEffect::Spotlight => "Sent with Spotlight",
             },
@@ -1078,7 +1105,7 @@ impl<'a> HTML<'a> {
 
 #[cfg(test)]
 mod tests {
-    use std::path::PathBuf;
+    use std::{env::current_dir, path::PathBuf};
 
     use crate::{
         app::attachment_manager::AttachmentManager, exporters::exporter::Writer, Config, Exporter,
@@ -1141,6 +1168,7 @@ mod tests {
             mime_type: Some("image/png".to_string()),
             transfer_name: Some("d.jpg".to_string()),
             total_bytes: 100,
+            is_sticker: false,
             hide_attachment: 0,
             copied_path: None,
         }
@@ -1542,6 +1570,31 @@ mod tests {
 
         assert_eq!(actual, Err("d.jpg"));
     }
+
+    #[test]
+    fn can_format_html_attachment_sticker() {
+        // Create exporter
+        let options = fake_options();
+        let config = Config::new(options).unwrap();
+        let exporter = HTML::new(&config);
+
+        let mut message = blank();
+        // Set message to sticker variant
+        message.associated_message_type = Some(1000);
+
+        let mut attachment = fake_attachment();
+        attachment.is_sticker = true;
+        let sticker_path = current_dir()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .join("imessage-database/test_data/stickers/outline.heic");
+        attachment.filename = Some(sticker_path.to_string_lossy().to_string());
+
+        let actual = exporter.format_sticker(&mut attachment, &message);
+
+        assert_eq!(actual, "<img src=\"/Users/chris/Documents/Code/Rust/imessage-exporter/imessage-database/test_data/stickers/outline.heic\" loading=\"lazy\">\n<div class=\"sticker_effect\">Sent with Outline effect</div>");
+    }
 }
 
 #[cfg(test)]
diff --git a/imessage-exporter/src/exporters/resources/style.css b/imessage-exporter/src/exporters/resources/style.css
index 7e8a2042..618c3a7d 100644
--- a/imessage-exporter/src/exporters/resources/style.css
+++ b/imessage-exporter/src/exporters/resources/style.css
@@ -264,6 +264,14 @@ div.reaction {
 	align-items: center;
 }
 
+div.sticker_effect {
+	opacity: 60%;
+}
+
+div.sticker img {
+	max-width: 5em;
+}
+
 .announcement {
 	text-align: center;
 	padding: 2vh 1vw 2vh 1vw;
diff --git a/imessage-exporter/src/exporters/txt.rs b/imessage-exporter/src/exporters/txt.rs
index 78d0683a..35a11908 100644
--- a/imessage-exporter/src/exporters/txt.rs
+++ b/imessage-exporter/src/exporters/txt.rs
@@ -201,13 +201,22 @@ impl<'a> Writer<'a> for TXT<'a> {
                     }
                 }
                 BubbleType::Attachment => match attachments.get_mut(attachment_index) {
-                    Some(attachment) => match self.format_attachment(attachment, message) {
-                        Ok(result) => {
-                            attachment_index += 1;
-                            self.add_line(&mut formatted_message, &result, &indent);
+                    Some(attachment) => {
+                        if attachment.is_sticker {
+                            let result = self.format_sticker(attachment, message);
+                            self.add_line(&mut formatted_message, &result, &indent)
+                        } else {
+                            match self.format_attachment(attachment, message) {
+                                Ok(result) => {
+                                    attachment_index += 1;
+                                    self.add_line(&mut formatted_message, &result, &indent);
+                                }
+                                Err(result) => {
+                                    self.add_line(&mut formatted_message, result, &indent)
+                                }
+                            }
                         }
-                        Err(result) => self.add_line(&mut formatted_message, result, &indent),
-                    },
+                    }
                     // Attachment does not exist in attachments table
                     None => self.add_line(&mut formatted_message, "Attachment missing!", &indent),
                 },
@@ -307,6 +316,23 @@ impl<'a> Writer<'a> for TXT<'a> {
         Ok(self.config.message_attachment_path(attachment))
     }
 
+    fn format_sticker(&self, sticker: &'a mut Attachment, message: &Message) -> String {
+        let who = self.config.who(&message.handle_id, message.is_from_me);
+        match self.format_attachment(sticker, message) {
+            Ok(path_to_sticker) => {
+                let sticker_effect = sticker.get_sticker_effect(
+                    &self.config.options.platform,
+                    &self.config.options.db_path,
+                );
+                if let Ok(Some(sticker_effect)) = sticker_effect {
+                    return format!("{sticker_effect} Sticker from {who}: {path_to_sticker}");
+                }
+                format!("Sticker from {who}: {path_to_sticker}")
+            }
+            Err(path) => format!("Sticker from {who}: {path}"),
+        }
+    }
+
     fn format_app(
         &self,
         message: &'a Message,
@@ -379,18 +405,13 @@ impl<'a> Writer<'a> for TXT<'a> {
                 ))
             }
             Variant::Sticker(_) => {
-                let paths = Attachment::from_message(&self.config.db, msg)?;
-                Ok(format!(
-                    "Sticker from {}: {}",
-                    self.config.who(&msg.handle_id, msg.is_from_me),
-                    match paths.get(0) {
-                        Some(sticker) => match sticker.filename.as_ref() {
-                            Some(path) => path,
-                            None => sticker.filename(),
-                        },
-                        None => "Sticker not found!",
-                    },
-                ))
+                let mut paths = Attachment::from_message(&self.config.db, msg)?;
+                let who = self.config.who(&msg.handle_id, msg.is_from_me);
+                // Sticker messages have only one attachment, the sticker image
+                Ok(match paths.get_mut(0) {
+                    Some(sticker) => self.format_sticker(sticker, msg),
+                    None => format!("Sticker from {who} not found!"),
+                })
             }
             _ => unreachable!(),
         }
@@ -405,7 +426,7 @@ impl<'a> Writer<'a> for TXT<'a> {
                 ScreenEffect::Balloons => "Sent with Balloons",
                 ScreenEffect::Heart => "Sent with Heart",
                 ScreenEffect::Lasers => "Sent with Lasers",
-                ScreenEffect::ShootingStar => "Sent with Shooting Start",
+                ScreenEffect::ShootingStar => "Sent with Shooting Star",
                 ScreenEffect::Sparkles => "Sent with Sparkles",
                 ScreenEffect::Spotlight => "Sent with Spotlight",
             },
@@ -707,7 +728,7 @@ impl<'a> TXT<'a> {
 
 #[cfg(test)]
 mod tests {
-    use std::path::PathBuf;
+    use std::{path::PathBuf, env::current_dir};
 
     use crate::{
         app::attachment_manager::AttachmentManager, exporters::exporter::Writer, Config, Exporter,
@@ -770,6 +791,7 @@ mod tests {
             mime_type: Some("image/png".to_string()),
             transfer_name: Some("d.jpg".to_string()),
             total_bytes: 100,
+            is_sticker: false,
             hide_attachment: 0,
             copied_path: None,
         }
@@ -1159,6 +1181,31 @@ mod tests {
 
         assert_eq!(actual, Err("d.jpg"));
     }
+
+    #[test]
+    fn can_format_html_attachment_sticker() {
+        // Create exporter
+        let options = fake_options();
+        let config = Config::new(options).unwrap();
+        let exporter = TXT::new(&config);
+
+        let mut message = blank();
+        // Set message to sticker variant
+        message.associated_message_type = Some(1000);
+
+        let mut attachment = fake_attachment();
+        attachment.is_sticker = true;
+        let sticker_path = current_dir()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .join("imessage-database/test_data/stickers/outline.heic");
+        attachment.filename = Some(sticker_path.to_string_lossy().to_string());
+
+        let actual = exporter.format_sticker(&mut attachment, &message);
+
+        assert_eq!(actual, "Outline Sticker from Me: /Users/chris/Documents/Code/Rust/imessage-exporter/imessage-database/test_data/stickers/outline.heic");
+    }
 }
 
 #[cfg(test)]