Receiving Gmail attachments via Mailgun

[meesix]

Hello,

I seem to have a problem receiving attachments from emails sent from Gmail web client. It all works well when using apps like Outlook, or Apple Mail, also works with Outlook web client, etc. Is this a known limitation? I assume Google has some custom mail structures that has to be adopted specifically for them?

django-anymail==10.3

Here is the code I use:

@receiver(inbound, sender=None)
def handle_inbound_email(sender, event, esp_name, **kwargs):
    logger.info(f"Received inbound email from {esp_name}")
    
    if esp_name != 'Mailgun':
        logger.info(f"Ignoring non-Mailgun email from {esp_name}")
        return  # Only process Mailgun emails
    
    logger.info(f"Processing Mailgun email")
    message = event.message
    
    # Debug - log all available attributes of the message object
    logger.info(f"Message attributes: {dir(message)}")
    logger.info(f"Message has attachments: {hasattr(message, 'attachments')}")
    if hasattr(message, 'attachments'):
        logger.info(f"Attachments length: {len(message.attachments)}")
    
    # Debug - log more details about the message payload
    if hasattr(message, '_payload'):
        logger.info(f"Message _payload keys: {message._payload.keys() if isinstance(message._payload, dict) else 'Not a dict'}")
        # Check for content-id-map which might indicate attachments
        if isinstance(message._payload, dict) and 'content-id-map' in message._payload:
            logger.info(f"Content-ID map: {message._payload['content-id-map']}")
        # Check for attachment count
        if isinstance(message._payload, dict) and 'attachment-count' in message._payload:
            logger.info(f"Attachment count from payload: {message._payload['attachment-count']}")
            
    # Debug - log raw data from event
    if hasattr(event, 'esp_event'):
        logger.info(f"ESP event type: {type(event.esp_event)}")
        
        # More detailed logging of esp_event structure
        if isinstance(event.esp_event, dict):
            logger.info(f"ESP event keys: {event.esp_event.keys()}")
            
            # Check for attachment data in esp_event
            for key in event.esp_event.keys():
                if key.startswith('attachment-'):
                    logger.info(f"Found attachment key: {key}")
                    attachment_data = event.esp_event[key]
                    logger.info(f"Attachment data type: {type(attachment_data)}")
                    
                    # If it's a file-like object or has useful attributes, log them
                    try:
                        if hasattr(attachment_data, 'name'):
                            logger.info(f"Attachment name: {attachment_data.name}")
                        if hasattr(attachment_data, 'content_type'):
                            logger.info(f"Attachment content_type: {attachment_data.content_type}")
                        if hasattr(attachment_data, 'size'):
                            logger.info(f"Attachment size: {attachment_data.size}")
                    except Exception as e:
                        logger.error(f"Error inspecting attachment: {e}")
                        
            # Check for specific form data that might contain attachments
            if 'form' in event.esp_event:
                form_data = event.esp_event['form']
                logger.info(f"Form data type: {type(form_data)}")
                if hasattr(form_data, 'keys'):
                    logger.info(f"Form data keys: {form_data.keys()}")
                    
                    # Check for attachment keys in form data
                    for key in form_data.keys():
                        if key.startswith('attachment-'):
                            logger.info(f"Found attachment in form: {key}")
                            
            # Log body content if available
            if 'body' in event.esp_event:
                logger.info("Body content available in esp_event")
                try:
                    # Try to parse as JSON to see if it contains attachment info
                    import json
                    body_data = json.loads(event.esp_event['body'])
                    logger.info(f"Body parsed as JSON with keys: {body_data.keys()}")
                    
                    if 'attachments' in body_data:
                        logger.info(f"Attachments found in body JSON: {len(body_data['attachments'])}")
                except Exception:
                    # Not JSON or other parsing error
                    pass
        
    try:
        # Extract email data from Anymail's parsed message
        message_id = ''
        in_reply_to = ''
        
       #...
        logger.info(f"Processing inbound email: {subject} from {from_email}")

        
        # Check various ways to detect attachments in Mailgun webhooks
        attachment_count = 0
        has_attachments = False
        
        # 1. Check for attachments directly on the message object
        if hasattr(message, 'attachments') and message.attachments:
            logger.info(f"Found attachments in message.attachments: {message.attachments}")
            attachment_count = len(message.attachments)
            has_attachments = attachment_count > 0
            
        # 2. Check for attachment-count in the payload
        if not has_attachments and hasattr(message, '_payload') and isinstance(message._payload, dict):
            # Check if attachment-count is in the payload
            if 'attachment-count' in message._payload:
                try:
                    raw_count = message._payload['attachment-count']
                    if isinstance(raw_count, list) and raw_count:
                        try:
                            attachment_count = int(raw_count[0])
                            has_attachments = attachment_count > 0
                        except (ValueError, TypeError):
                            logger.error(f"Error converting {raw_count[0]} to int")
                    else:
                        try:
                            attachment_count = int(str(raw_count))
                            has_attachments = attachment_count > 0
                        except (ValueError, TypeError):
                            logger.error(f"Error converting {raw_count} to int")
                    
                    logger.info(f"Found attachment-count: {attachment_count} in message payload")
                except (IndexError, TypeError) as e:
                    logger.error(f"Error parsing attachment count: {e}")
                    
        # 3. Check for actual attachment keys in the payload
        if not has_attachments and hasattr(message, '_payload') and isinstance(message._payload, dict):
            # Look for attachment-1, attachment-2, etc. keys
            attachment_keys = [k for k in message._payload.keys() if k.startswith('attachment-')]
            if attachment_keys:
                attachment_count = len(attachment_keys)
                has_attachments = True
                logger.info(f"Found {attachment_count} attachment keys: {attachment_keys}")
                
        # 4. If we have esp_event data, try to find attachments there
        if not has_attachments and hasattr(event, 'esp_event') and isinstance(event.esp_event, dict):
            # Look for attachment keys directly in esp_event
            attachment_keys = [k for k in event.esp_event.keys() if k.startswith('attachment-')]
            if attachment_keys:
                attachment_count = len(attachment_keys)
                has_attachments = True
                logger.info(f"Found {attachment_count} attachment keys in esp_event: {attachment_keys}")
            elif 'attachments' in event.esp_event:
                attachment_data = event.esp_event['attachments']
                if isinstance(attachment_data, list):
                    attachment_count = len(attachment_data)
                    has_attachments = attachment_count > 0
                    logger.info(f"Found {attachment_count} attachments in esp_event")
                    
        logger.info(f"Processing email with {attachment_count} attachments")
        
        # Create the email record
        # (...)
        
        logger.info(f"Created email record with ID: {email.pk}")
        
        # Process attachments if any
        if has_attachments:
            logger.info(f"Will process {attachment_count} attachments")
            
            # Method 1: Try attachments directly from the message object
            if hasattr(message, 'attachments') and message.attachments:
                for i, attachment in enumerate(message.attachments, 1):
                    try:
                        logger.info(f"Processing attachment {i} from message.attachments")
                        
                        # (...)
                        
                        if not content:
                            logger.error(f"No content found in attachment: {attachment_str}")
                            continue
                        
                        logger.info(f"Attachment details: {filename}, {content_type}, {len(content)} bytes")
                        
                        logger.info(f"Saved attachment {filename}")
                    except Exception as e:
                        logger.error(f"Error processing attachment from message.attachments: {str(e)}")
                        continue
                        
            # Method 2: For Mailgun, try attachments directly from the ESP event
            elif hasattr(event, 'esp_event') and isinstance(event.esp_event, dict):
                logger.info(f"Processing attachments from esp_event dictionary")
                
                # Look for attachment-1, attachment-2, etc. keys in esp_event
                attachment_keys = [k for k in event.esp_event.keys() if k.startswith('attachment-')]
                
                for key in attachment_keys:
                    try:
                        logger.info(f"Processing attachment {key}")
                        attachment_data = event.esp_event[key]
                        
                        # Check what type of object we have
                        logger.info(f"Attachment data type: {type(attachment_data)}")
                        
                        # Try different ways to get the file info
                        filename = None
                        content_type = None
                        content = None
                        
                        # If it's a file-like object
                        if hasattr(attachment_data, 'name'):
                            filename = attachment_data.name
                        
                        if hasattr(attachment_data, 'content_type'):
                            content_type = attachment_data.content_type
                            
                        # If we still don't have a filename, use the key
                        if not filename:
                            filename = f"{key}.bin"
                            
                        # If we don't have a content type, use a default
                        if not content_type:
                            content_type = 'application/octet-stream'
                            
                        # Try to get content
                        if hasattr(attachment_data, 'read'):
                            content = attachment_data.read()
                        elif hasattr(attachment_data, 'file') and hasattr(attachment_data.file, 'read'):
                            content = attachment_data.file.read()
                        # If it's a list, take the first item
                        elif isinstance(attachment_data, list) and attachment_data:
                            file_obj = attachment_data[0]
                            if hasattr(file_obj, 'read'):
                                content = file_obj.read()
                                # Update filename and content_type if available
                                if hasattr(file_obj, 'name'):
                                    filename = file_obj.name
                                if hasattr(file_obj, 'content_type'):
                                    content_type = file_obj.content_type
                                    
                        if content is None:
                            logger.error(f"Could not extract content from {key}")
                            continue
                            
                        logger.info(f"Attachment details from esp_event: {filename}, {content_type}, {len(content)} bytes")
                        
                        # ...
                        logger.info(f"Saved attachment {filename}")
                    except Exception as e:
                        logger.error(f"Error processing attachment {key}: {str(e)}")
                        continue
            
            # Method 3: Try attachments from the esp_event
            elif hasattr(event, 'esp_event') and isinstance(event.esp_event, dict) and 'attachments' in event.esp_event:
                attachments_data = event.esp_event['attachments']
                if isinstance(attachments_data, list):
                    for i, attachment_data in enumerate(attachments_data, 1):
                        try:
                            logger.info(f"Processing attachment {i} from esp_event")
                            
                            # Extract attachment info
                            filename = attachment_data.get('filename', f'attachment-{i}')
                            content_type = attachment_data.get('content_type', 'application/octet-stream')
                            content = attachment_data.get('content')
                            
                            if not content:
                                logger.error(f"No content found in attachment: {attachment_data}")
                                continue
                                
                            # Content might be base64 encoded
                            if isinstance(content, str):
                                import base64
                                content = base64.b64decode(content)
                                
                            logger.info(f"Attachment details: {filename}, {content_type}, {len(content)} bytes")
                                
                           #...
                        except Exception as e:
                            logger.error(f"Error processing attachment from esp_event: {str(e)}")
                            continue
                            
            # Method 4: Handle attachments that are provided as raw strings with headers + content
            else:
                logger.info("Trying to process attachments as strings with headers and content")
                
                # Check in message payload or esp_event for attachment data as strings
                attachment_sources = []
                
                # Check in message payload
                if hasattr(message, '_payload') and isinstance(message._payload, dict):
                    for key, value in message._payload.items():
                        if key.startswith('attachment-') and isinstance(value, str):
                            attachment_sources.append((key, value))
                
                # Check if the attachments are AnymailInboundMessage objects but not handled yet
                if hasattr(message, 'attachments') and message.attachments:
                    for i, attachment in enumerate(message.attachments, 1):
                        try:
                            # Only process if it's not already handled
                            key = f"attachment-{i}"
                            
                            if hasattr(attachment, 'as_string'):
                                attachment_str = attachment.as_string()
                                attachment_sources.append((key, attachment_str))
                                logger.info(f"Added AnymailInboundMessage as string, length: {len(attachment_str)}")
                            elif hasattr(attachment, 'as_bytes'):
                                attachment_bytes = attachment.as_bytes()
                                try:
                                    attachment_str = attachment_bytes.decode('utf-8', errors='replace')
                                    attachment_sources.append((key, attachment_str))
                                    logger.info(f"Added AnymailInboundMessage as bytes->string, length: {len(attachment_str)}")
                                except Exception as e:
                                    logger.error(f"Error converting bytes to string: {e}")
                        except Exception as e:
                            logger.error(f"Error processing AnymailInboundMessage as string: {e}")
                
                # Check in esp_event
                if hasattr(event, 'esp_event') and isinstance(event.esp_event, dict):
                    for key, value in event.esp_event.items():
                        if key.startswith('attachment-') and isinstance(value, str):
                            attachment_sources.append((key, value))
                
                # Process each attachment string
                for i, (key, attachment_str) in enumerate(attachment_sources, 1):
                    try:
                        logger.info(f"Processing attachment string {i}: {key}")
                        
                        # Parse the attachment string - it may contain headers and content
                        filename, content_type, content = _parse_attachment_string(attachment_str)
                        
                        if not content:
                            logger.error(f"No content extracted from attachment string: {key}")
                            continue
                            
                        logger.info(f"Extracted attachment details: {filename}, {content_type}, {len(content)} bytes")
                        
                        #...

                        logger.info(f"Saved attachment {filename}")
                    except Exception as e:
                        logger.error(f"Error processing attachment string: {str(e)}")
                        continue
        
        logger.info(f"Successfully processed email {email.pk} with {attachment_count} attachments")
        
    except Exception as e:
        logger.error(f"Error processing inbound email: {str(e)}")
        # Don't raise the exception - this would cause Anymail to retry
        # Instead, log the error and continue

And here are logs for outlook email:

2025-09-23 12:28:53,514 INFO Received inbound email from Mailgun
2025-09-23 12:28:53,515 INFO Processing Mailgun email
2025-09-23 12:28:53,516 INFO Message attributes: ['__bytes__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_add_multipart', '_body_types', '_charset', '_default_type', '_find_body', '_get_body_content', '_get_params_preserve', '_headers', '_make_multipart', '_payload', '_unixfrom', 'add_alternative', 'add_attachment', 'add_header', 'add_related', 'as_bytes', 'as_string', 'as_uploaded_file', 'attach', 'attachments', 'bcc', 'cc', 'clear', 'clear_content', 'construct', 'construct_attachment', 'construct_attachment_from_uploaded_file', 'content_id_map', 'date', 'defects', 'del_param', 'envelope_recipient', 'envelope_sender', 'epilogue', 'from_email', 'get', 'get_address_header', 'get_all', 'get_body', 'get_boundary', 'get_charset', 'get_charsets', 'get_content', 'get_content_bytes', 'get_content_charset', 'get_content_disposition', 'get_content_maintype', 'get_content_subtype', 'get_content_text', 'get_content_type', 'get_date_header', 'get_default_type', 'get_filename', 'get_param', 'get_params', 'get_payload', 'get_unixfrom', 'html', 'inline_attachments', 'inlines', 'is_attachment', 'is_inline', 'is_inline_attachment', 'is_multipart', 'items', 'iter_attachments', 'iter_parts', 'keys', 'make_alternative', 'make_mixed', 'make_related', 'parse_raw_mime', 'parse_raw_mime_bytes', 'parse_raw_mime_file', 'policy', 'preamble', 'raw_items', 'replace_header', 'set_boundary', 'set_charset', 'set_content', 'set_default_type', 'set_param', 'set_payload', 'set_raw', 'set_type', 'set_unixfrom', 'spam_detected', 'spam_score', 'stripped_html', 'stripped_text', 'subject', 'text', 'to', 'values', 'walk']
2025-09-23 12:28:53,516 INFO Message has attachments: True
2025-09-23 12:28:53,517 INFO Attachments length: 1
2025-09-23 12:28:53,517 INFO Message _payload keys: Not a dict
2025-09-23 12:28:53,518 INFO ESP event type: <class 'django.core.handlers.asgi.ASGIRequest'>
2025-09-23 12:28:53,528 INFO Processing inbound email: Incoming email from Outlook from <..>
2025-09-23 12:28:53,557 INFO Found attachments in message.attachments: [<anymail.inbound.AnymailInboundMessage object at 0x7aa9f497c6e0>]
2025-09-23 12:28:53,558 INFO Processing email with 1 attachments
2025-09-23 12:28:53,570 INFO Created email record with ID: 42
2025-09-23 12:28:53,570 INFO Will process 1 attachments
2025-09-23 12:28:53,570 INFO Processing attachment 1 from message.attachments
2025-09-23 12:28:53,574 INFO Raw attachment: Content-Type: application/vnd.openxmlformats-officedocument.wordprocessingml.document;
 name="Delive...
2025-09-23 12:28:53,575 INFO Attachment details: Deliverables description.docx, application/vnd.openxmlformats-officedocument.wordprocessingml.document, 26646 bytes
2025-09-23 12:28:53,607 INFO Saved attachment Deliverables description.docx
2025-09-23 12:28:53,608 INFO Successfully processed email 42 with 1 attachments

And this is GMAIL email:

2025-09-23 12:36:34,949 INFO Received inbound email from Mailgun
2025-09-23 12:36:34,949 INFO Processing Mailgun email
2025-09-23 12:36:34,949 INFO Message attributes: ['__bytes__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_add_multipart', '_body_types', '_charset', '_default_type', '_find_body', '_get_body_content', '_get_params_preserve', '_headers', '_make_multipart', '_payload', '_unixfrom', 'add_alternative', 'add_attachment', 'add_header', 'add_related', 'as_bytes', 'as_string', 'as_uploaded_file', 'attach', 'attachments', 'bcc', 'cc', 'clear', 'clear_content', 'construct', 'construct_attachment', 'construct_attachment_from_uploaded_file', 'content_id_map', 'date', 'defects', 'del_param', 'envelope_recipient', 'envelope_sender', 'epilogue', 'from_email', 'get', 'get_address_header', 'get_all', 'get_body', 'get_boundary', 'get_charset', 'get_charsets', 'get_content', 'get_content_bytes', 'get_content_charset', 'get_content_disposition', 'get_content_maintype', 'get_content_subtype', 'get_content_text', 'get_content_type', 'get_date_header', 'get_default_type', 'get_filename', 'get_param', 'get_params', 'get_payload', 'get_unixfrom', 'html', 'inline_attachments', 'inlines', 'is_attachment', 'is_inline', 'is_inline_attachment', 'is_multipart', 'items', 'iter_attachments', 'iter_parts', 'keys', 'make_alternative', 'make_mixed', 'make_related', 'parse_raw_mime', 'parse_raw_mime_bytes', 'parse_raw_mime_file', 'policy', 'preamble', 'raw_items', 'replace_header', 'set_boundary', 'set_charset', 'set_content', 'set_default_type', 'set_param', 'set_payload', 'set_raw', 'set_type', 'set_unixfrom', 'spam_detected', 'spam_score', 'stripped_html', 'stripped_text', 'subject', 'text', 'to', 'values', 'walk']
2025-09-23 12:36:34,949 INFO Message has attachments: True
2025-09-23 12:36:34,949 INFO Attachments length: 0
2025-09-23 12:36:34,950 INFO Message _payload keys: Not a dict
2025-09-23 12:36:34,950 INFO ESP event type: <class 'django.core.handlers.asgi.ASGIRequest'>
2025-09-23 12:36:34,950 INFO Processing inbound email: Gmail Hello from <..>
2025-09-23 12:36:34,963 INFO Processing email with 0 attachments
2025-09-23 12:36:34,969 INFO Created email record with ID: 43
2025-09-23 12:36:34,969 INFO Successfully processed email 43 with 0 attachments

[meesix]

I'm looking at Mailgun logs now, and it looks like they are aware of the attachment:

		"attachments": [
			{
				"content-type": "application/rtf",
				"filename": "- Quick Setup.rtf",
				"size": 4147
			}
		],

[medmunds]

I assume Google has some custom mail structures that has to be adopted specifically for them?

No, Google's Gmail apps tend to send well-formatted email that follows all relevant standards. Special handing should not be necessary.

A few things to look at:

1. Attachments may show up as either attachments or inlines, depending on what email app the sender used and how they composed the message. You'll want to check both. (Images often show up as inlines rather than attachments.)

2. Be sure you are using Mailgun's "raw mime" inbound handling (the forwarding destination url ends in /inbound_mime/). Otherwise some attachments may be missing.

3. That's a lot of code in your inbound receiver function. If it's something temporary you wrote for debugging purposes, it's fine. But if an AI wrote it for production use, I suggest selecting the entire function and giving the AI this prompt:
   

   This code seems really complex. I thought the whole point of django-anymail is that it normalizes ESP-specific APIs so we don't have to know the details. Can we rewrite handle_inbound_email to something much simpler? All the data we want should be available from the AnymailInboundMessage message object: see https://anymail.dev/en/stable/inbound/#normalized-inbound-message. We'll need to look at both attachments and inlines to get all attachment-like content. (But we shouldn't be accessing the internal, undocumented _payload attribute.) And we should use idiomatic Python to keep it simple. For example, we can just access documented attributes directly, without needing hasattr or getattr.

[meesix]

Thank you so much! Indeed in my case I found attachments in inlines. And thank you so much for the prompt, I manually removed all the necessary debug, now it's only 108 lines (including handling chains, and saving mail to database).

This monstrosity of a code was my attempt to figure out where are attachments are gone (and of course with use of some co-pilot). But of course they are not needed.