# Receiving Email - Google App Engine - Google Code

English ▼
Skip to page content Skip to main navigation
e.g. "templates" or "datastore"

# Receiving Email

Email messages sent to your app are implemented as HTTP requests. To process incoming email messages, you associate email addresses with script handlers in your app configuration, then include the handlers in your app's code. Incoming email generates HTTP requests, which are passed to the appropriate scripts.

## Configuring Your App to Receive Email

When you create a new app, incoming email is disabled by default. To enable the incoming email service, you must modify your `app.yaml` file in two ways:

1. Add an `inbound_services` section that enables the incoming email service.
2. Add mappings that associate URL-mapped email addresses with script handlers.

To enable the incoming email service, add a short section to your `app.yaml` file, like the following:

    inbound_services:
    - mail

You can verify that you have enabled incoming email in your app by going to the Administration Console and checking the Application Settings section. Note that you can only check there to see if the incoming email service is enabled; you must change the `app.yaml` file to actually enable or disable the service. If you don't enable incoming email by including this section in your configuration file, incoming email is disabled, and email messages sent to the app are ignored.

Your app can receive email at addresses of the following form:

      string@appid.appspotmail.com

Email messages are sent to your app as HTTP POST requests using the following URL:

      /_ah/mail/address

where address is a full email address, including domain name. To handle incoming email in your app, you map email URLs to handlers in the `app.yaml` file:

    - url: /_ah/mail/.+
      script: handle_incoming_email.py
      login: admin

In this example, /_ah/mail/.+ matches all email addressed to the app.

If you prefer, you can set up multiple handlers for different email addresses, as in the following example:

    - url: /_ah/mail/owner@.*your_app_id\.appspotmail\.com
      script: handle_owner.py
      login: admin
    - url: /_ah/mail/support@.*your_app_id\.appspotmail\.com
      script: handle_support.py
      login: admin
    - url: /_ah/mail/.+
      script: handle_catchall.py
      login: admin

URLs of incoming email messages are matched to this list from first to last, so if an email message URL matches more than one pattern, the first matching handler will be the one executed. This allows you to include a "catchall" handler as the last mapping.

## Handling Incoming Email

The Python SDK defines `InboundMailHandler`, a webapp class for handling incoming email. To use `InboundMailHandler`, you subclass it and override the `receive()` method. The `receive()` method is called with an argument of class `InboundEmailMessage`, another class defined by the Python SDK.

`InboundMailHandler` is in the `google.appengine.ext.webapp.mail_handlers` package. You can create an instance of `InboundEmailMessage` like this:

    import logging, email
    from google.appengine.ext import webapp
    from google.appengine.ext.webapp.mail_handlers import InboundMailHandler
    from google.appengine.ext.webapp.util import run_wsgi_app

    class LogSenderHandler(InboundMailHandler):
        def receive(self, mail_message):
            logging.info("Received a message from: " + mail_message.sender)

InboundMailHandler contains a `mapping()` convenience method that returns a pair matching all incoming email addresses to the mail handler:

    application = webapp.WSGIApplication([LogSenderHandler.mapping()], debug=True)

The `InboundEmailMessage` object contains the email message. Its `bodies()` method returns the message body, or possibly multiple message bodies. If you call `bodies()` without arguments, it returns an iterator that returns HTML bodies first, then plain text bodies. If you want just HTML or just plain text, you can pass an argument to `bodies()`, as follows:

        plaintext_bodies = message.bodies('text/plain')
        html_bodies = message.bodies('text/html')

        for content_type, body in html_bodies:
            decoded_html = body.decode()
            # ...

The `InboundEmailMessage` object includes attributes to access other message fields:

- `subject` contains the message subject.
- `sender` is the sender's address e.g. `"Nobody <nobody@example.com>"`.
- `to` is a comma-seperated list of the message's primary recipients e.g. `"Joe <joe@example.com>, Bill <bill@example.com>"`.
- `cc` contains a comma-seperated list of the cc recipients e.g. `"Joe <joe@example.com>, Bill <bill@example.com>"`.
- `date` returns the message date.
- `attachments` is a list of file attachments, possibly empty. Each value in the list is a tuple of two elements: the filename and the file contents.
- `original` is the complete message, including data not exposed by the other fields such as email headers, as a Python email.message.Message.

Once you set up your app to handle incoming email, you can use the development server console to simulate incoming email messages. You can access the development server by going to http://localhost:8080/_ah/admin/ (or if your app is running on a port other than 8080, use that value instead). In the development server, click Inbound Mail on the left side, fill out the form that appears, and click Send Email. To learn more, including how to get the development server running, see The Python Development Server.