diff --git a/README.md b/README.md
index 7bd0a638..57229897 100644
--- a/README.md
+++ b/README.md
@@ -57,6 +57,7 @@ The table below identifies the services this tool supports and some example serv
 | [Pushover](https://github.com/caronc/apprise/wiki/Notify_pushover)  | pover://   | (TCP) 443   | pover://user@token<br />pover://user@token/DEVICE<br />pover://user@token/DEVICE1/DEVICE2/DEVICEN<br />**Note**: you must specify both your user_id and token
 | [Rocket.Chat](https://github.com/caronc/apprise/wiki/Notify_rocketchat) | rocket:// or rockets://  | (TCP) 80 or 443   | rocket://user:password@hostname/RoomID/Channel<br />rockets://user:password@hostname:443/#Channel1/#Channel1/RoomID<br />rocket://user:password@hostname/#Channel<br />rocket://webhook@hostname<br />rockets://webhook@hostname/@User/#Channel
 | [Ryver](https://github.com/caronc/apprise/wiki/Notify_ryver) | ryver://  | (TCP) 443   | ryver://Organization/Token<br />ryver://botname@Organization/Token
+| [SendGrid](https://github.com/caronc/apprise/wiki/Notify_sendgrid) | sendgrid://  | (TCP) 443   | sendgrid://APIToken:FromEmail/<br />sendgrid://APIToken:FromEmail/ToEmail<br />sendgrid://APIToken:FromEmail/ToEmail1/ToEmail2/ToEmailN/
 | [Slack](https://github.com/caronc/apprise/wiki/Notify_slack) | slack://  | (TCP) 443   | slack://TokenA/TokenB/TokenC/<br />slack://TokenA/TokenB/TokenC/Channel<br />slack://botname@TokenA/TokenB/TokenC/Channel<br />slack://user@TokenA/TokenB/TokenC/Channel1/Channel2/ChannelN
 | [Telegram](https://github.com/caronc/apprise/wiki/Notify_telegram) | tgram://  | (TCP) 443   | tgram://bottoken/ChatID<br />tgram://bottoken/ChatID1/ChatID2/ChatIDN
 | [Twitter](https://github.com/caronc/apprise/wiki/Notify_twitter) | twitter://  | (TCP) 443   | twitter://CKey/CSecret/AKey/ASecret<br/>twitter://user@CKey/CSecret/AKey/ASecret<br/>twitter://CKey/CSecret/AKey/ASecret/User1/User2/User2<br/>twitter://CKey/CSecret/AKey/ASecret?mode=tweet
diff --git a/apprise/plugins/NotifyEmail.py b/apprise/plugins/NotifyEmail.py
index a83b46ec..b854a21b 100644
--- a/apprise/plugins/NotifyEmail.py
+++ b/apprise/plugins/NotifyEmail.py
@@ -195,6 +195,23 @@ EMAIL_TEMPLATES = (
         },
     ),
 
+    # SendGrid (Email Server)
+    # You must specify an authenticated sender address in the from= settings
+    # and a valid email in the to= to deliver your emails to
+    (
+        'SendGrid',
+        re.compile(
+            r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
+            r'(?P<domain>(\.smtp)?sendgrid\.(com|net))$', re.I),
+        {
+            'port': 465,
+            'smtp_host': 'smtp.sendgrid.net',
+            'secure': True,
+            'secure_mode': SecureMailMode.SSL,
+            'login_type': (WebBaseLogin.USERID, )
+        },
+    ),
+
     # Catch All
     (
         'Custom',
@@ -399,11 +416,17 @@ class NotifyEmail(NotifyBase):
             # over-riding any smarts to be applied
             return
 
+        # detect our email address using our user/host combo
+        from_addr = '{}@{}'.format(
+            re.split(r'[\s@]+', self.user)[0],
+            self.host,
+        )
+
         for i in range(len(EMAIL_TEMPLATES)):  # pragma: no branch
-            self.logger.debug('Scanning %s against %s' % (
-                self.from_addr, EMAIL_TEMPLATES[i][0]
+            self.logger.trace('Scanning %s against %s' % (
+                from_addr, EMAIL_TEMPLATES[i][0]
             ))
-            match = EMAIL_TEMPLATES[i][1].match(self.from_addr)
+            match = EMAIL_TEMPLATES[i][1].match(from_addr)
             if match:
                 self.logger.info(
                     'Applying %s Defaults' %
diff --git a/apprise/plugins/NotifySendGrid.py b/apprise/plugins/NotifySendGrid.py
new file mode 100644
index 00000000..c759fbdf
--- /dev/null
+++ b/apprise/plugins/NotifySendGrid.py
@@ -0,0 +1,473 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2019 Chris Caron <lead2gold@gmail.com>
+# All rights reserved.
+#
+# This code is licensed under the MIT License.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files(the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions :
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# You will need an API Key for this plugin to work.
+# From the Settings -> API Keys you can click "Create API Key" if you don't
+# have one already. The key must have at least the "Mail Send" permission
+# to work.
+#
+# The schema to use the plugin looks like this:
+#    {schema}://{apikey}:{from_email}
+#
+# Your {from_email} must be comprissed of your Sendgrid Authenticated
+# Domain. The same domain must have 'Link Branding' turned on as well or it
+# will not work. This can be seen from Settings -> Sender Authentication.
+
+# If you're (SendGrid) verified domain is example.com, then your schema may
+# look something like this:
+
+# Simple API Reference:
+#  - https://sendgrid.com/docs/API_Reference/Web_API_v3/index.html
+#  - https://sendgrid.com/docs/ui/sending-email/\
+#       how-to-send-an-email-with-dynamic-transactional-templates/
+
+import re
+import requests
+from json import dumps
+
+from .NotifyBase import NotifyBase
+from ..common import NotifyFormat
+from ..common import NotifyType
+from ..utils import parse_list
+from ..utils import GET_EMAIL_RE
+from ..AppriseLocale import gettext_lazy as _
+
+IS_APIKEY_RE = re.compile(r'^([A-Z0-9._-]+)$', re.I)
+
+# Extend HTTP Error Messages
+SENDGRID_HTTP_ERROR_MAP = {
+    401: 'Unauthorized - You do not have authorization to make the request.',
+    413: 'Payload To Large - The JSON payload you have included in your '
+         'request is too large.',
+    429: 'Too Many Requests - The number of requests you have made exceeds '
+         'SendGrid’s rate limitations.',
+}
+
+
+class NotifySendGrid(NotifyBase):
+    """
+    A wrapper for Notify SendGrid Notifications
+    """
+
+    # The default descriptive name associated with the Notification
+    service_name = 'SendGrid'
+
+    # The services URL
+    service_url = 'https://sendgrid.com'
+
+    # The default secure protocol
+    secure_protocol = 'sendgrid'
+
+    # A URL that takes you to the setup/help of the specific protocol
+    setup_url = 'https://github.com/caronc/apprise/wiki/Notify_sendgrid'
+
+    # Default to markdown
+    notify_format = NotifyFormat.HTML
+
+    # The default Email API URL to use
+    notify_url = 'https://api.sendgrid.com/v3/mail/send'
+
+    # Allow 300 requests per minute.
+    # 60/300 = 0.2
+    request_rate_per_sec = 0.2
+
+    # The default subject to use if one isn't specified.
+    default_empty_subject = '<no subject>'
+
+    # Define object templates
+    templates = (
+        '{schema}://{apikey}:{from_email}',
+        '{schema}://{apikey}:{from_email}/{targets}',
+    )
+
+    # Define our template arguments
+    template_tokens = dict(NotifyBase.template_tokens, **{
+        'apikey': {
+            'name': _('API Key'),
+            'type': 'string',
+            'private': True,
+            'required': True,
+        },
+        'from_email': {
+            'name': _('Source Email'),
+            'type': 'string',
+            'required': True,
+        },
+        'target_email': {
+            'name': _('Target Email'),
+            'type': 'string',
+            'map_to': 'targets',
+        },
+        'targets': {
+            'name': _('Targets'),
+            'type': 'list:string',
+        },
+    })
+
+    # Define our template arguments
+    template_args = dict(NotifyBase.template_args, **{
+        'to': {
+            'alias_of': 'targets',
+        },
+        'cc': {
+            'name': _('Carbon Copy'),
+            'type': 'list:string',
+        },
+        'bcc': {
+            'name': _('Blind Carbon Copy'),
+            'type': 'list:string',
+        },
+        'template': {
+            # Template ID
+            # The template ID is 64 characters with one dash (d-uuid)
+            'name': _('Template'),
+            'type': 'string',
+        },
+    })
+
+    # Support Template Dynamic Variables (Substitutions)
+    template_kwargs = {
+        'template_data': {
+            'name': _('Template Data'),
+            'prefix': '+',
+        },
+    }
+
+    def __init__(self, apikey, from_email, targets=None, cc=None,
+                 bcc=None, template=None, template_data=None, **kwargs):
+        """
+        Initialize Notify SendGrid Object
+        """
+        super(NotifySendGrid, self).__init__(**kwargs)
+
+        # The API Key needed to perform all SendMail API i/o
+        self.apikey = apikey
+        try:
+            result = IS_APIKEY_RE.match(self.apikey)
+            if not result:
+                # let outer exception handle this
+                raise TypeError
+
+        except (TypeError, AttributeError):
+            msg = 'Invalid API Key specified: {}'.format(self.apikey)
+            self.logger.warning(msg)
+            raise TypeError(msg)
+
+        self.from_email = from_email
+        try:
+            result = GET_EMAIL_RE.match(self.from_email)
+            if not result:
+                # let outer exception handle this
+                raise TypeError
+
+        except (TypeError, AttributeError):
+            msg = 'Invalid ~From~ email specified: {}'.format(self.from_email)
+            self.logger.warning(msg)
+            raise TypeError(msg)
+
+        # Acquire Targets (To Emails)
+        self.targets = list()
+
+        # Acquire Carbon Copies
+        self.cc = set()
+
+        # Acquire Blind Carbon Copies
+        self.bcc = set()
+
+        # Now our dynamic template (if defined)
+        self.template = template
+
+        # Now our dynamic template data (if defined)
+        self.template_data = template_data \
+            if isinstance(template_data, dict) else {}
+
+        # Validate recipients (to:) and drop bad ones:
+        for recipient in parse_list(targets):
+
+            if GET_EMAIL_RE.match(recipient):
+                self.targets.append(recipient)
+                continue
+
+            self.logger.warning(
+                'Dropped invalid email '
+                '({}) specified.'.format(recipient),
+            )
+
+        # Validate recipients (cc:) and drop bad ones:
+        for recipient in parse_list(cc):
+
+            if GET_EMAIL_RE.match(recipient):
+                self.cc.add(recipient)
+                continue
+
+            self.logger.warning(
+                'Dropped invalid Carbon Copy email '
+                '({}) specified.'.format(recipient),
+            )
+
+        # Validate recipients (bcc:) and drop bad ones:
+        for recipient in parse_list(bcc):
+
+            if GET_EMAIL_RE.match(recipient):
+                self.bcc.add(recipient)
+                continue
+
+            self.logger.warning(
+                'Dropped invalid Blind Carbon Copy email '
+                '({}) specified.'.format(recipient),
+            )
+
+        if len(self.targets) == 0:
+            # Notify ourselves
+            self.targets.append(self.from_email)
+
+        return
+
+    def url(self):
+        """
+        Returns the URL built dynamically based on specified arguments.
+        """
+
+        # Define any arguments set
+        args = {
+            'format': self.notify_format,
+            'overflow': self.overflow_mode,
+            'verify': 'yes' if self.verify_certificate else 'no',
+        }
+
+        if len(self.cc) > 0:
+            # Handle our Carbon Copy Addresses
+            args['cc'] = ','.join(self.cc)
+
+        if len(self.bcc) > 0:
+            # Handle our Blind Carbon Copy Addresses
+            args['bcc'] = ','.join(self.bcc)
+
+        if self.template:
+            # Handle our Template ID if if was specified
+            args['template'] = self.template
+
+        # Append our template_data into our args
+        args.update({'+{}'.format(k): v
+                    for k, v in self.template_data.items()})
+
+        # a simple boolean check as to whether we display our target emails
+        # or not
+        has_targets = \
+            not (len(self.targets) == 1 and self.targets[0] == self.from_email)
+
+        return '{schema}://{apikey}:{from_email}/{targets}?{args}'.format(
+            schema=self.secure_protocol,
+            apikey=self.quote(self.apikey, safe=''),
+            from_email=self.quote(self.from_email, safe='@'),
+            targets='' if not has_targets else '/'.join(
+                [NotifySendGrid.quote(x, safe='') for x in self.targets]),
+            args=NotifySendGrid.urlencode(args),
+        )
+
+    def send(self, body, title='', notify_type=NotifyType.INFO, **kwargs):
+        """
+        Perform SendGrid Notification
+        """
+
+        headers = {
+            'User-Agent': self.app_id,
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer {}'.format(self.apikey),
+        }
+
+        # error tracking (used for function return)
+        has_error = False
+
+        # A Simple Email Payload Template
+        _payload = {
+            'personalizations': [{
+                # Placeholder
+                'to': [{'email': None}],
+            }],
+            'from': {
+                'email': self.from_email,
+            },
+            # A subject is a requirement, so if none is specified we must
+            # set a default with at least 1 character or SendGrid will deny
+            # our request
+            'subject': title if title else self.default_empty_subject,
+            'content': [{
+                'type': 'text/plain'
+                if self.notify_format == NotifyFormat.TEXT else 'text/html',
+                'value': body,
+            }],
+        }
+
+        if self.template:
+            _payload['template_id'] = self.template
+
+            if self.template_data:
+                _payload['personalizations'][0]['dynamic_template_data'] = \
+                    {k: v for k, v in self.template_data.items()}
+
+        targets = list(self.targets)
+        while len(targets) > 0:
+            target = targets.pop(0)
+
+            # Create a copy of our template
+            payload = _payload.copy()
+
+            # the cc, bcc, to field must be unique or SendMail will fail, the
+            # below code prepares this by ensuring the target isn't in the cc
+            # list or bcc list. It also makes sure the cc list does not contain
+            # any of the bcc entries
+            cc = (self.cc - self.bcc - set([target]))
+            bcc = (self.bcc - set([target]))
+
+            # Set our target
+            payload['personalizations'][0]['to'][0]['email'] = target
+
+            if len(cc):
+                payload['personalizations'][0]['cc'] = \
+                    [{'email': email} for email in cc]
+
+            if len(bcc):
+                payload['personalizations'][0]['bcc'] = \
+                    [{'email': email} for email in bcc]
+
+            self.logger.debug('SendGrid POST URL: %s (cert_verify=%r)' % (
+                self.notify_url, self.verify_certificate,
+            ))
+            self.logger.debug('SendGrid Payload: %s' % str(payload))
+
+            # Always call throttle before any remote server i/o is made
+            self.throttle()
+            try:
+                r = requests.post(
+                    self.notify_url,
+                    data=dumps(payload),
+                    headers=headers,
+                    verify=self.verify_certificate,
+                )
+                if r.status_code not in (
+                        requests.codes.ok, requests.codes.accepted):
+                    # We had a problem
+                    status_str = \
+                        NotifySendGrid.http_response_code_lookup(
+                            r.status_code, SENDGRID_HTTP_ERROR_MAP)
+
+                    self.logger.warning(
+                        'Failed to send SendGrid notification to {}: '
+                        '{}{}error={}.'.format(
+                            target,
+                            status_str,
+                            ', ' if status_str else '',
+                            r.status_code))
+
+                    self.logger.debug(
+                        'Response Details:\r\n{}'.format(r.content))
+
+                    # Mark our failure
+                    has_error = True
+                    continue
+
+                else:
+                    self.logger.info(
+                        'Sent SendGrid notification to {}.'.format(target))
+
+            except requests.RequestException as e:
+                self.logger.warning(
+                    'A Connection error occured sending SendGrid '
+                    'notification to {}.'.format(target))
+                self.logger.debug('Socket Exception: %s' % str(e))
+
+                # Mark our failure
+                has_error = True
+                continue
+
+        return not has_error
+
+    @staticmethod
+    def parse_url(url):
+        """
+        Parses the URL and returns enough arguments that can allow
+        us to substantiate this object.
+
+        """
+
+        results = NotifyBase.parse_url(url)
+        if not results:
+            # We're done early as we couldn't load the results
+            return results
+
+        # Our URL looks like this:
+        #    {schema}://{apikey}:{from_email}/{targets}
+        #
+        # which actually equates to:
+        #    {schema}://{user}:{password}@{host}/{email1}/{email2}/etc..
+        #                 ^       ^         ^
+        #                 |       |         |
+        #              apikey     -from addr-
+
+        if not results.get('user'):
+            # An API Key as not properly specified
+            return None
+
+        if not results.get('password'):
+            # A From Email was not correctly specified
+            return None
+
+        # Prepare our API Key
+        results['apikey'] = NotifySendGrid.unquote(results['user'])
+
+        # Prepare our From Email Address
+        results['from_email'] = '{}@{}'.format(
+            NotifySendGrid.unquote(results['password']),
+            NotifySendGrid.unquote(results['host']),
+        )
+
+        # Acquire our targets
+        results['targets'] = NotifySendGrid.split_path(results['fullpath'])
+
+        # The 'to' makes it easier to use yaml configuration
+        if 'to' in results['qsd'] and len(results['qsd']['to']):
+            results['targets'] += \
+                NotifySendGrid.parse_list(results['qsd']['to'])
+
+        # Handle Carbon Copy Addresses
+        if 'cc' in results['qsd'] and len(results['qsd']['cc']):
+            results['cc'] = \
+                NotifySendGrid.parse_list(results['qsd']['cc'])
+
+        # Handle Blind Carbon Copy Addresses
+        if 'bcc' in results['qsd'] and len(results['qsd']['bcc']):
+            results['bcc'] = \
+                NotifySendGrid.parse_list(results['qsd']['bcc'])
+
+        # Handle Blind Carbon Copy Addresses
+        if 'template' in results['qsd'] and len(results['qsd']['template']):
+            results['template'] = \
+                NotifySendGrid.unquote(results['qsd']['template'])
+
+        # Add any template substitutions
+        results['template_data'] = results['qsd+']
+
+        return results
diff --git a/packaging/redhat/python-apprise.spec b/packaging/redhat/python-apprise.spec
index 7b4fdd35..208a0b3f 100644
--- a/packaging/redhat/python-apprise.spec
+++ b/packaging/redhat/python-apprise.spec
@@ -50,8 +50,8 @@ it easy to access:
 Boxcar, Discord, E-Mail, Emby, Faast, Flock, Gitter, Gotify, Growl, IFTTT,
 Join, KODI, Mailgun, MatterMost, Matrix, Microsoft Windows Notifications,
 Microsoft Teams, Nexmo, Notify MyAndroid, Prowl, Pushalot, PushBullet, Pushjet,
-Pushover, Rocket.Chat, Slack, Super Toasty, Stride, Techulus Push, Telegram,
-Twilio, Twitter, Twist, XBMC, XMPP, Webex Teams}
+Pushover, Rocket.Chat, SendGrid, Slack, Super Toasty, Stride, Techulus Push,
+Telegram, Twilio, Twitter, Twist, XBMC, XMPP, Webex Teams}
 
 Name:           python-%{pypi_name}
 Version:        0.7.9
diff --git a/setup.py b/setup.py
index 4a8417f2..27c5f948 100755
--- a/setup.py
+++ b/setup.py
@@ -72,8 +72,8 @@ setup(
     keywords='Push Notifications Alerts Email AWS SNS Boxcar Discord Dbus '
         'Emby Faast Flock Gitter Gnome Gotify Growl IFTTT Join KODI Mailgun '
         'Matrix Mattermost Nexmo Prowl PushBullet Pushjet Pushed Pushover '
-        'Rocket.Chat Ryver Slack Stride Techulus Push Telegram Twilio Twist '
-        'Twitter XBMC Microsoft MSTeams Windows Webex CLI API',
+        'Rocket.Chat Ryver SendGrid Slack Stride Techulus Push Telegram '
+        'Twilio Twist Twitter XBMC Microsoft MSTeams Windows Webex CLI API',
     author='Chris Caron',
     author_email='lead2gold@gmail.com',
     packages=find_packages(),
diff --git a/test/test_rest_plugins.py b/test/test_rest_plugins.py
index 0e340f16..b8a6fc2c 100644
--- a/test/test_rest_plugins.py
+++ b/test/test_rest_plugins.py
@@ -1853,6 +1853,80 @@ TEST_URLS = (
         'test_requests_exceptions': True,
     }),
 
+    ##################################
+    # NotifySendGrid
+    ##################################
+    ('sendgrid://', {
+        'instance': None,
+    }),
+    ('sendgrid://:@/', {
+        'instance': None,
+    }),
+    ('sendgrid://abcd', {
+        # Just an broken email (no api key or email)
+        'instance': None,
+    }),
+    ('sendgrid://abcd@host', {
+        # Just an Email specified, no API Key
+        'instance': None,
+    }),
+    ('sendgrid://invalid-api-key+*-d:user@example.com', {
+        # An invalid API Key
+        'instance': TypeError,
+    }),
+    ('sendgrid://abcd:user@example.com', {
+        # No To/Target Address(es) specified; so we sub in the same From
+        # address
+        'instance': plugins.NotifySendGrid,
+    }),
+    ('sendgrid://abcd:user@example.com/newuser@example.com', {
+        # A good email
+        'instance': plugins.NotifySendGrid,
+    }),
+    ('sendgrid://abcd:user@example.com/newuser@example.com'
+     '?bcc=l2g@nuxref.com', {
+         # A good email with Blind Carbon Copy
+         'instance': plugins.NotifySendGrid,
+     }),
+    ('sendgrid://abcd:user@example.com/newuser@example.com'
+     '?cc=l2g@nuxref.com', {
+         # A good email with Carbon Copy
+         'instance': plugins.NotifySendGrid,
+     }),
+    ('sendgrid://abcd:user@example.com/newuser@example.com'
+     '?to=l2g@nuxref.com', {
+         # A good email with Carbon Copy
+         'instance': plugins.NotifySendGrid,
+     }),
+    ('sendgrid://abcd:user@example.com/newuser@example.com'
+     '?template={}'.format(UUID4), {
+         # A good email with a template + no substitutions
+         'instance': plugins.NotifySendGrid,
+     }),
+    ('sendgrid://abcd:user@example.com/newuser@example.com'
+     '?template={}&+sub=value&+sub2=value2'.format(UUID4), {
+         # A good email with a template + substitutions
+         'instance': plugins.NotifySendGrid,
+     }),
+    ('sendgrid://abcd:user@example.ca/newuser@example.ca', {
+        'instance': plugins.NotifySendGrid,
+        # force a failure
+        'response': False,
+        'requests_response_code': requests.codes.internal_server_error,
+    }),
+    ('sendgrid://abcd:user@example.uk/newuser@example.uk', {
+        'instance': plugins.NotifySendGrid,
+        # throw a bizzare code forcing us to fail to look it up
+        'response': False,
+        'requests_response_code': 999,
+    }),
+    ('sendgrid://abcd:user@example.au/newuser@example.au', {
+        'instance': plugins.NotifySendGrid,
+        # Throws a series of connection and transfer exceptions when this flag
+        # is set and tests that we gracfully handle them
+        'test_requests_exceptions': True,
+    }),
+
     ##################################
     # NotifySlack
     ##################################
@@ -3835,6 +3909,56 @@ def test_notify_zulip_plugin():
         assert True
 
 
+@mock.patch('requests.get')
+@mock.patch('requests.post')
+def test_notify_sendgrid_plugin(mock_post, mock_get):
+    """
+    API: NotifySendGrid() Extra Checks
+
+    """
+    # Disable Throttling to speed testing
+    plugins.NotifyBase.request_rate_per_sec = 0
+
+    try:
+        # no apikey
+        plugins.NotifySendGrid(
+            apikey=None, from_email='user@example.com')
+        # We shouldn't get here; we should thrown an exception instead
+        assert False
+
+    except TypeError:
+        assert True
+
+    try:
+        plugins.NotifySendGrid(
+            apikey='abcd', from_email='!invalid')
+        # We shouldn't get here; we should thrown an exception instead
+        assert False
+
+    except TypeError:
+        assert True
+
+    try:
+        # no email
+        plugins.NotifySendGrid(apikey='abcd', from_email=None)
+        # We shouldn't get here; we should thrown an exception instead
+        assert False
+
+    except TypeError:
+        assert True
+
+    # Invalid To email address
+    plugins.NotifySendGrid(
+        apikey='abcd', from_email='user@example.com', targets="!invalid")
+
+    # Test invalid bcc/cc entries mixed with good ones
+    assert isinstance(plugins.NotifySendGrid(
+        apikey='abcd',
+        from_email='l2g@example.com',
+        bcc=('abc@def.com', '!invalid'),
+        cc=('abc@test.org', '!invalid')), plugins.NotifySendGrid)
+
+
 @mock.patch('requests.get')
 @mock.patch('requests.post')
 def test_notify_slack_plugin(mock_post, mock_get):