Eight (Condensed) Steps to Better Email Deliverability

The primary focus of JangoMail is to provide customizable and personalized email deliverability that will separate our customers from their competitors.
These eight steps will help you to better understand the services JangoMail can provide for your company’s email delivery system and how you can get started on the path to better email deliverability with your company.

1. Branding Your From Address – Anyone can create a free Gmail or Yahoo account and send an email under your company’s name. Having a branded email domain will allow recipients to clearly see who is sending a message and will more likely lead them to click and open, which means more transactions for your company.
2. Customizing Your Tracking Domain – Every new JangoMail customer acquires an assigned tracking domain that is the same as multiple other clients’. Personalizing your tracking domain name to fit your company will set you apart from the rest of our customers, maximizing your customization.
3. Setting Up Domain Keys/DKIM – The email authentication standards Domain Keys and DKIM allow senders to securely deliver messages and eliminate fraudulent emails.
4. Confirming Yahoo Feedback Loop – After completing step 3, Yahoo will send a verification email that will set up a feedback loop between your company’s postmaster, Yahoo and JangoMail. This will allow any recipient complaints to be properly heard by all three parties and conveniently dealt with.
5. Creating an SPF Record – Setting up a SenderID on your domain will allow proper diagnosis of forgery, spam, worms and viruses in your system. 

   

   
   

6. Plain Text Message – To lower scrutiny from spam filters, the best idea is to send a corresponding plain text message with every HTML email you deliver.
7. Return Path Program – Two levels of high-reputation sending are available through JangoMail. The first level is being a member of the Safe List, which allows a sender to preferential treatment from spam filters. The second level of whitelisting is being included on the Certified List, which grants the user access to send emails with the highest standard and through optimal preferential treatment.
8. Anchor hyperlinks with Text Phrases and not URLS – This practice keeps phishing filters from believing your message is fraudulent.
   
   

For the expanded version of this list, including graphics and detailed information, go to https://jangomail.zendesk.com/hc/en-us/articles/200660134-Eight-Steps-to-Set-Up-Email-Deliverability.

Introducing…Our NEW User Interface

By: Melonie Mottice
Marketing Specialist

The wait is over! We are pleased to announce our new user interface here at JangoMail.  The new design combines the old with the new.  We’ve taken suggestions directly from you, our valued clients.  Enjoy our fresh new look that is easy to use and navigate, delivering the latest to you in email technology.

Here are our new features:

New Look: You’ll notice new matching colors to the site along with a well organized, easy to use dashboard that houses popular links.  These shortcuts are not only visually appealing, but convenient for easy access.

Walkthrough Guides:  Each user will appreciate the walkthrough guides which give an interactive tour of the entire system.  You will initially be prompted to take the tour, but can recall or hide the guides at anytime.

Navigation: The most important change has been made to our navigation.  JangoMail now has submenus which allow users to access features within the Reports, Messages, and List sections without interrupting any work.

Help Section: Whether you need a quick reference point or have an in-depth question, our help sections are everywhere.  Access explanations, useful links, tutorials and tips on each page to the right.

Countdown:  At the very top of the page, you’ll notice our new countdown feature which tracks the number of days left in your usage period, your next usage period, data used, and number of sent messages.  Note the Upgrade Account button next to the countdown for an easy upgrade.

The goal of our new interface was to improve our overall look and usability. We hope you enjoy our new features and look forward to answering any questions you may have.  Please don't hesitate to call us at 855-709-4099, or submit a ticket at jangomail.com/support.

Calling the JangoMail API in Ruby Using SOAP

If you're integrating in a Ruby environment, then Savon is a great, versatile way to call SOAP web services. In this example, we use savon to build a soap client for the JangoMail API, then call Groups_GetList_String. To test it with your own account, just insert your own JangoMail/JangoSMTP credentials. Download the source code for this example to start your own integration!

# make sure to include savon for building soap requests
# see http://savonrb.com/ to download
require 'savon'

# first, build the soap client from the wsdl
client = Savon::Client.new 
    "http://api.jangomail.com/api.asmx?wsdl"

# specify the xml for the request, inserting your credentials
response = client.request 
    "http://api.jangomail.com/Groups_GetList_String" do |soap|
  soap.xml = """<?xml version=\"1.0\" encoding=\"utf-8\"?>
    <soap12:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSch...
    <soap12:Body>
    <Groups_GetList_String xmlns=\"http://api.jangomail.com/\">
    <Username>Your JangoMail/JangoSMTP Username</Username>
    <Password>Your JangoMail/JangoSMTP Password</Password>
    <RowDelimiter> </RowDelimiter>
    <ColDelimiter> - </ColDelimiter>
    <TextQualifier></TextQualifier>
    </Groups_GetList_String></soap12:Body></soap12:Envelope>"""
end

Calling the JangoMail Web Service in Python

Python is a language that seems to make so many mundane programming tasks easy. Unfortunately, some python libraries are perhaps less fully developed than the libraries of other languages. This is certainly the case of the python soap libraries SOAPpy and SUDS. In my experience, both libraries are painfully buggy. In python, I think it's easier just to use httplib and build the xml manually. Luckily, python's other conveniences make that pretty easy!

In this example, we build an xml template for calling Groups_GetList_String. To test it with your own account, just insert your own JangoMail/JangoSMTP credentials. Download the source code for this example to start your own integration!

import sys
import httplib

# setup the sml template xml for a call to Groups_GetList_String
SM_TEMPLATE = """<?xml version="1.0" encoding="utf-8"?>
<soap12:Envelope 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
    xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
  <soap12:Body>
    <Groups_GetList_String xmlns="http://api.jangomail.com/">
      <Username>%s</Username>
      <Password>%s</Password>
      <RowDelimiter>%s</RowDelimiter>
      <ColDelimiter>%s</ColDelimiter>
      <TextQualifier>%s</TextQualifier>
    </Groups_GetList_String>
  </soap12:Body>
</soap12:Envelope>
"""

# fill in the parameters for our call
SoapMessage = SM_TEMPLATE%("Your JangoMail/JangoSMTP Username", 
              "Your Password", "\n", " - ", "")

# examine the soap message that we have constructed
print SoapMessage

# insert the proper values into the header
webservice = httplib.HTTP("api.jangomail.com")
webservice.putrequest("POST", "/api.asmx")
webservice.putheader("Host", "api.jangomail.com")
webservice.putheader("User-Agent", "Python post")
webservice.putheader("Content-type", 
    "application/soap+xml; charset=\"UTF-8\"")
webservice.putheader("Content-length", "%d" % len(SoapMessage))
webservice.putheader("SOAPAction", 
    "http://api.jangomail.com/Groups_GetList_String")
webservice.endheaders()
webservice.send(SoapMessage)

# get the response and print it
statuscode, statusmessage, header = webservice.getreply()
print "Response: ", statuscode, statusmessage
print "headers: ", header
res = webservice.getfile().read()
print res

Consuming the JangoMail API in ASP.Net

It's easy to start integrating the JangoMail API into your company's .Net software. Start by adding a service reference to your project. Right click on the project in the solution explorer, then click "Add a Service Reference". Under Address, enter http://api.jangomail.com/api.asmx?WSDL and click "Go". Then change the namespace to JangoMail and click "OK". This will add the files necessary to reference the JangoMail web service within your application or website. Then you can call all the JangoMail/JangoSMTP API methods from within your software.

In this two line example, a JangoMailSoapClient object is created, then used to invoke the method that gets a list of the email lists on your account. Download the source code for this example then start your own integration!

// first create the JangoMail soap client object
JangoMail.JangoMailSoapClient j = 
    new JangoMail.JangoMailSoapClient("JangoMailSoap");

// then call the getlist method and display the results
Result.InnerHtml = 
    j.Groups_GetList_String("Your JangoMail/JangoSMTP Username", 
                            "Your JangoMail/JangoSMTP Password", 
                            "<br/>", " - ", "");

Integrating the JangoMail API Into a Java Application

If you want to integrate JangoMail's web service into your company's existing Java software, this example will show you how to hit the ground running. This example relies on Java's built-in library for processing soap requests javax.xml.soap. Download the source code for this example here.

In the first part of this example, the SOAPMessage is created. In this case, we will call the Groups_GetList_String method, which will return a list of groups on your account. Make sure to set the SOAPAction header to indicate which method you want to call.

// create the connection
SOAPConnectionFactory soapConnFactory 
    = SOAPConnectionFactory.newInstance();
SOAPConnection connection = soapConnFactory.createConnection();

//Next, create the actual message/request
MessageFactory messageFactory = MessageFactory.newInstance();
SOAPMessage message = messageFactory.createMessage();
          
//Create objects for the request parts            
SOAPPart soapPart = message.getSOAPPart();
SOAPEnvelope envelope = soapPart.getEnvelope();
SOAPBody body = envelope.getBody();
  
// set the SOAPAction Header to the desired request
MimeHeaders headers = message.getMimeHeaders();
headers.addHeader("SOAPAction", 
    "http://api.jangomail.com/Groups_GetList_String");

Next, the message is populated with our parameters and sent to the JangoMail servers.

// Populate the body of the request
// create the main element and namespace
SOAPElement bodyElement = body.addChildElement(
        envelope.createName("Groups_GetList_String", 
                            "", 
                            "http://api.jangomail.com/"));
   
// add the parameters
bodyElement.addChildElement("Username")
    .addTextNode("Your JangoMail/JangoSMTP Username");
bodyElement.addChildElement("Password")
    .addTextNode("Your JangoMail/JangoSMTP Password");
bodyElement.addChildElement("RowDelimiter").addTextNode("\n");
bodyElement.addChildElement("ColDelimiter").addTextNode(" - ");
bodyElement.addChildElement("TextQualifier").addTextNode("");
   
// save the message
message.saveChanges();
   
// Send the message and print the reply
// set the destination
String destination = "http://api.jangomail.com/api.asmx";
// send the message
SOAPMessage reply = connection.call(message, destination);

Finally, the response is received and printed.

//Check the output
System.out.println("\nRESPONSE:\n");

//Create the transformer
TransformerFactory transformerFactory 
    = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();

//Extract the content of the reply
Source sourceContent = reply.getSOAPPart().getContent();

//Set the output for the transformation
StreamResult result = new StreamResult(System.out);
transformer.transform(sourceContent, result);
System.out.println();

Make sure to Download the complete source code for this example and populate it with the values from your JangoMail or JangoSMTP account.