diff --git a/src/dc_receive_imf.rs b/src/dc_receive_imf.rs
index b4896d40a..e050cd08e 100644
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -55,7 +55,7 @@ pub fn dc_receive_imf(
         println!("{}", String::from_utf8_lossy(imf_raw));
     }
 
-    let mut mime_parser = MimeParser::from_bytes(context, imf_raw)?;
+    let mut mime_parser = MimeMessage::from_bytes(context, imf_raw)?;
 
     // we can not add even an empty record if we have no info whatsoever
     ensure!(mime_parser.has_headers(), "No Headers Found");
@@ -251,7 +251,7 @@ pub fn dc_receive_imf(
 
 fn add_parts(
     context: &Context,
-    mut mime_parser: &mut MimeParser,
+    mut mime_parser: &mut MimeMessage,
     imf_raw: &[u8],
     incoming: bool,
     incoming_origin: Origin,
@@ -651,7 +651,7 @@ fn add_parts(
 
 fn save_locations(
     context: &Context,
-    mime_parser: &MimeParser,
+    mime_parser: &MimeMessage,
     chat_id: u32,
     from_id: u32,
     insert_msg_id: MsgId,
@@ -750,7 +750,7 @@ fn calc_timestamps(
 #[allow(non_snake_case)]
 fn create_or_lookup_group(
     context: &Context,
-    mime_parser: &mut MimeParser,
+    mime_parser: &mut MimeMessage,
     allow_creation: bool,
     create_blocked: Blocked,
     from_id: u32,
@@ -1055,7 +1055,7 @@ fn create_or_lookup_group(
 }
 
 /// try extract a grpid from a message-id list header value
-fn extract_grpid(mime_parser: &MimeParser, headerdef: HeaderDef) -> Option<String> {
+fn extract_grpid(mime_parser: &MimeMessage, headerdef: HeaderDef) -> Option<String> {
     if let Some(value) = mime_parser.get(headerdef) {
         for part in value.split(',').map(str::trim) {
             if !part.is_empty() {
@@ -1071,7 +1071,7 @@ fn extract_grpid(mime_parser: &MimeParser, headerdef: HeaderDef) -> Option<Strin
 /// Handle groups for received messages, return chat_id/Blocked status on success
 fn create_or_lookup_adhoc_group(
     context: &Context,
-    mime_parser: &MimeParser,
+    mime_parser: &MimeMessage,
     allow_creation: bool,
     create_blocked: Blocked,
     from_id: u32,
@@ -1307,7 +1307,7 @@ fn search_chat_ids_by_contact_ids(
 
 fn check_verified_properties(
     context: &Context,
-    mimeparser: &MimeParser,
+    mimeparser: &MimeMessage,
     from_id: u32,
     to_ids: &ContactIds,
 ) -> Result<()> {
@@ -1409,7 +1409,7 @@ fn check_verified_properties(
     Ok(())
 }
 
-fn set_better_msg(mime_parser: &mut MimeParser, better_msg: impl AsRef<str>) {
+fn set_better_msg(mime_parser: &mut MimeMessage, better_msg: impl AsRef<str>) {
     let msg = better_msg.as_ref();
     if !msg.is_empty() && !mime_parser.parts.is_empty() {
         let part = &mut mime_parser.parts[0];
@@ -1419,7 +1419,7 @@ fn set_better_msg(mime_parser: &mut MimeParser, better_msg: impl AsRef<str>) {
     }
 }
 
-fn is_reply_to_known_message(context: &Context, mime_parser: &MimeParser) -> bool {
+fn is_reply_to_known_message(context: &Context, mime_parser: &MimeMessage) -> bool {
     /* check if the message is a reply to a known message; the replies are identified by the Message-ID from
     `In-Reply-To`/`References:` (to support non-Delta-Clients) */
 
@@ -1474,7 +1474,7 @@ fn is_known_rfc724_mid(context: &Context, rfc724_mid: &mailparse::MailAddr) -> b
 /// - checks also if any of the referenced IDs are send by a messenger
 /// - it is okay, if the referenced messages are moved to trash here
 /// - no check for the Chat-* headers (function is only called if it is no messenger message itself)
-fn is_reply_to_messenger_message(context: &Context, mime_parser: &MimeParser) -> bool {
+fn is_reply_to_messenger_message(context: &Context, mime_parser: &MimeMessage) -> bool {
     if let Some(value) = mime_parser.get(HeaderDef::InReplyTo) {
         if is_msgrmsg_rfc724_mid_in_list(context, &value) {
             return true;
@@ -1619,7 +1619,7 @@ mod tests {
                     References: <Gr.HcxyMARjyJy.9-uvzWPTLtV@nauta.cu>\n\
                     \n\
                     hello\x00";
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(extract_grpid(&mimeparser, HeaderDef::InReplyTo), None);
         let grpid = Some("HcxyMARjyJy".to_string());
         assert_eq!(extract_grpid(&mimeparser, HeaderDef::References), grpid);
@@ -1634,7 +1634,7 @@ mod tests {
                     References: <qweqweqwe>, <Gr.HcxyMARjyJy.9-uvzWPTLtV@nau.ca>\n\
                     \n\
                     hello\x00";
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         let grpid = Some("HcxyMARjyJy".to_string());
         assert_eq!(extract_grpid(&mimeparser, HeaderDef::InReplyTo), grpid);
         assert_eq!(extract_grpid(&mimeparser, HeaderDef::References), grpid);
diff --git a/src/mimeparser.rs b/src/mimeparser.rs
index 40fc3ee5b..fa5fabcc8 100644
--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -26,8 +26,17 @@ use crate::simplify::*;
 use crate::stock::StockMessage;
 use crate::{bail, ensure};
 
+/// A parsed MIME message.
+///
+/// This represents the relevant information of a parsed MIME message
+/// for deltachat.  The original MIME message might have had more
+/// information but this representation should contain everything
+/// needed for deltachat's purposes.
+///
+/// It is created by parsing the raw data of an actual MIME message
+/// using the [MimeMessage::from_raw] constructor.
 #[derive(Debug)]
-pub struct MimeParser<'a> {
+pub struct MimeMessage<'a> {
     pub context: &'a Context,
     pub parts: Vec<Part>,
     header: HashMap<String, String>,
@@ -82,11 +91,11 @@ impl Default for SystemMessage {
 
 const MIME_AC_SETUP_FILE: &str = "application/autocrypt-setup";
 
-impl<'a> MimeParser<'a> {
+impl<'a> MimeMessage<'a> {
     pub fn from_bytes(context: &'a Context, body: &[u8]) -> Result<Self> {
         let mail = mailparse::parse_mail(body)?;
 
-        let mut parser = MimeParser {
+        let mut parser = MimeMessage {
             parts: Vec::new(),
             header: Default::default(),
             decrypting_failed: false,
@@ -1039,7 +1048,7 @@ mod tests {
     fn test_dc_mimeparser_crash() {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
 
         assert_eq!(mimeparser.get_subject(), None);
         assert_eq!(mimeparser.parts.len(), 1);
@@ -1052,7 +1061,7 @@ mod tests {
             let context = dummy_context();
 
             // just don't crash
-            let _ = MimeParser::from_bytes(&context.ctx, data.as_bytes());
+            let _ = MimeMessage::from_bytes(&context.ctx, data.as_bytes());
         }
     }
 
@@ -1060,7 +1069,7 @@ mod tests {
     fn test_get_rfc724_mid_exists() {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/mail_with_message_id.txt");
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
 
         assert_eq!(
             mimeparser.get_rfc724_mid(),
@@ -1072,7 +1081,7 @@ mod tests {
     fn test_get_rfc724_mid_not_exists() {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/issue_523.txt");
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.get_rfc724_mid(), None);
     }
 
@@ -1080,7 +1089,7 @@ mod tests {
     fn test_get_recipients() {
         let context = dummy_context();
         let raw = include_bytes!("../test-data/message/mail_with_cc.txt");
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         let recipients = get_recipients(mimeparser.header.iter());
         assert!(recipients.contains("abc@bcd.com"));
         assert!(recipients.contains("def@def.de"));
@@ -1134,7 +1143,7 @@ mod tests {
                     test1\n\
                     ";
 
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
 
         let of = mimeparser.parse_first_addr(HeaderDef::From_).unwrap();
         assert_eq!(of, mailparse::addrparse("hello@one.org").unwrap()[0]);
@@ -1164,7 +1173,7 @@ mod tests {
                     --==break==--\n\
                     \n";
 
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
 
         // non-overwritten headers do not bubble up
         let of = mimeparser.get(HeaderDef::SecureJoinGroup).unwrap();
@@ -1189,26 +1198,26 @@ mod tests {
         let t = dummy_context();
 
         let raw = include_bytes!("../test-data/message/mail_attach_txt.eml");
-        let mimeparser = MimeParser::from_bytes(&t.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.user_avatar, AvatarAction::None);
         assert_eq!(mimeparser.group_avatar, AvatarAction::None);
 
         let raw = include_bytes!("../test-data/message/mail_with_user_avatar.eml");
-        let mimeparser = MimeParser::from_bytes(&t.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.parts[0].typ, Viewtype::Text);
         assert!(mimeparser.user_avatar.is_change());
         assert_eq!(mimeparser.group_avatar, AvatarAction::None);
 
         let raw = include_bytes!("../test-data/message/mail_with_user_avatar_deleted.eml");
-        let mimeparser = MimeParser::from_bytes(&t.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.parts[0].typ, Viewtype::Text);
         assert_eq!(mimeparser.user_avatar, AvatarAction::Delete);
         assert_eq!(mimeparser.group_avatar, AvatarAction::None);
 
         let raw = include_bytes!("../test-data/message/mail_with_user_and_group_avatars.eml");
-        let mimeparser = MimeParser::from_bytes(&t.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.parts[0].typ, Viewtype::Text);
         assert!(mimeparser.user_avatar.is_change());
@@ -1218,7 +1227,7 @@ mod tests {
         let raw = include_bytes!("../test-data/message/mail_with_user_and_group_avatars.eml");
         let raw = String::from_utf8_lossy(raw).to_string();
         let raw = raw.replace("Chat-User-Avatar:", "Xhat-Xser-Xvatar:");
-        let mimeparser = MimeParser::from_bytes(&t.ctx, raw.as_bytes()).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&t.ctx, raw.as_bytes()).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.parts[0].typ, Viewtype::Image);
         assert_eq!(mimeparser.user_avatar, AvatarAction::None);
@@ -1255,7 +1264,7 @@ Content-Disposition: attachment; filename=\"message.kml\"\n\
 --==break==--\n\
 ;";
 
-        let mimeparser = MimeParser::from_bytes(&context.ctx, &raw[..]).unwrap();
+        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..]).unwrap();
         assert_eq!(
             mimeparser.get_subject(),
             Some("Location streaming".to_string())
diff --git a/src/securejoin.rs b/src/securejoin.rs
index 2c1bb89b2..dbfa70661 100644
--- a/src/securejoin.rs
+++ b/src/securejoin.rs
@@ -341,7 +341,7 @@ impl Default for HandshakeMessageStatus {
 /// Handle incoming secure-join handshake.
 pub(crate) fn handle_securejoin_handshake(
     context: &Context,
-    mimeparser: &MimeParser,
+    mimeparser: &MimeMessage,
     contact_id: u32,
 ) -> Result<HandshakeMessageStatus, Error> {
     let own_fingerprint: String;
@@ -717,7 +717,7 @@ fn mark_peer_as_verified(context: &Context, fingerprint: impl AsRef<str>) -> Res
  * Tools: Misc.
  ******************************************************************************/
 
-fn encrypted_and_signed(mimeparser: &MimeParser, expected_fingerprint: impl AsRef<str>) -> bool {
+fn encrypted_and_signed(mimeparser: &MimeMessage, expected_fingerprint: impl AsRef<str>) -> bool {
     if !mimeparser.was_encrypted() {
         warn!(mimeparser.context, "Message not encrypted.",);
         false