Command Center: Bob Discovers the JangoMail API

By: JangoMail Development
Bob's business is growing. Bob's sales staff needs to use email to make more connections with leads, and to promote more sales to existing customers. Bob's sales staff, however, isn't so great at learning new things. Bob already has his own software to run his business, and his sales staff doesn't like going outside of it to use other tools.

Bob needs his sales staff to use JangoMail's tools, but he wants them to do so directly from his own sales software. After all, his IT and development staff have worked hard to make his software work very well for his purposes.

That's why Bob uses the JangoMail API. API stands for Application Programming Interface. The JangoMail API lets Bob's developer connect his software directly to JangoMail.

Now Bob's sales staff can create messages, build contact lists, and send campaigns directly from Bob's own software. Bob's sales software, with JangoMail's API, brings more power, success, and money to Bob's organization.

But wait, there's more! The JangoMail API gives Bob's software access to reporting, transactional and campaign sending, contact management, account management, and many more features. Almost everything you can do within JangoMail can be done through the JangoMail API. Check for bounces. Count your opens. Do it all!

If you act now, we'll also include the ability to make requests through SOAP, HTTP GET, or HTTP POST. We'll even let you pull the data as string, .NET dataset, or XML.

All of this, AND MORE, for the great low, low price of nothing in addition to your normal subscription costs. That's right, access to the API is free for JangoMail customers. Yes, even free trial customers.

Want to know more about how the JangoMail API like Bob does? Click here to read more. You'll be cool if you do it, just like Bob.

Meet the Team - Erick Pece

What do salt and vinegar chips, mountain biking, and 'refresh your screen' all have in common?  They are synonymous with Erick Pece, JangoMail's Director of Technical Support!

1.  What is your position at JangoMail?

Meet Erick Pece, JangoMail's
Director of Technical Support

Director of Technical Support

2.  How long have you worked for JangoMail?

Close to three years

3.  How do you use JangoMail personally?

I use JangoMail both for internal support team use to send notifications, scheduling reminders, etc...I also use JangoMail for a few non-profit projects I'm involved in.

4.  What do you like best about working for JangoMail?

The team environment and flexibility to provide customers with the best support options - we're not reading from scripts! 

5.  What feature do you like most?

I have a background in software development, so my first choice would be our API, since it allows people to integrate with our system directly inside their own.  After that, the ability to connect directly to a web database is my next choice!

6.  What is your educational background or what experience led you here?

I have a Bachelor's in Computer Science and Information Management, and have had experience as a systems and network administrator at several other companies.  The team-oriented environment led me to JangoMail.

7.  What is your favorite hobby / pastime?

Mountain biking.

8.  What is your guilty pleasure?

Baked Salt and Vinegar chips. I can't stop myself when they're around!

9.  What is one random fact people don't know about you?

After graduating college in 2008, I haven't lived anywhere for more than 1.5 years until now.  I've been living in the same city for just over 2 years - we're on a roll!

10. Do you have a catchphrase, funny saying, or personal quote?

I often develop internal tools for our support team to provide them with the best information, which in turn allows them to provide customers with that information. Depending on my workload, I'll sometimes get requests to add features to these tools.  In some cases, I'm able to turn around that request in 5-10 minutes, at which point I'll say, "Refresh your screen."  I guess I'd say that's a phrase I've become known for by the support team.

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

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.

Using the JangoMail API in PHP

Since PHP 5 provided developers with the SoapClient class, it's a snap to consume SOAP-enabled web services in a PHP script.

This example demonstrates how to connect to the JangoMail API in order to get the email lists on your account. Download the source code for this example, insert your own JangoMail credentials, and you're ready to start integrating the JangoMail API with your php website.

// create a SoapClient object for the jangomail aPI
$client = 
    new SoapClient("http://api.jangomail.com/api.asmx?WSDL");

// set the parameter array for the
// Groups_GetList_String method
$param=array(
 'Username'=>'Your JangoMail Username',
 'Password'=>'Your JangoMail Password',
 'RowDelimiter'=>'<br/>',
 'ColDelimiter'=>' - ',
 'TextQualifier'=>''
); 

// using the JangoMail API
// call the Groups_GetList_String method
$result = $client->Groups_GetList_String($param);

// print the groups that were returned
print($result->Groups_GetList_StringResult);

New Feature: Event API for Transactional Emails

We are excited to announce our newest feature: an event API for transactional emails. The transactional email event API is a system that can call any web service or web page on your server upon a specified transactional email event. The following transactional email events can trigger a call to your web service:

1. A sent email
2. An open of an email
3. A click of a URL in an email
4. An unsubscribe
5. A bounce
6. A complaint, via Feedback Loop

The transactional email event API is now offered in addition to our long-time existing broadcast email event API, which is covered in this PDF tutorial, this blog post for ASP.Net users, and this blog post for users who use a custom web service.

Why is the transactional email event API important?

You can now easily sync transactional email data with your own database or CRM system using the Event API. You only need one script on your web server to handle the calls from JangoMail. The calls are made in real-time when an event happens.

How do I set up an event-based web service call?

To set this up, go to Settings --> Integrating JangoMail with Other Systems --> Transactional Event API.  Click on the tab for each event for which you would like a web service called, and then enter the details for the web service.

What is the difference between the "Transactional Email Event API" and the "Standard API"?

The Standard API allows a programmer to interact with JangoMail much like a user would interact with JangoMail through the web-based interface. With the Standard API, you can pull reporting data, and send transactional email. The Event API pushes event data (opens, clicks, etc.) to your system when the event happens. The Standard API needs to be polled by your system to retrieve open or click data.

Some notes on this feature:

1. If there are 1,000 consecutive failures when calling a specific web service for a specific event, then calls to the web service will cease until the URL or one of the parameters is modified. A failure is any HTTP response that is not status 200.
2. When you first designate a web service and its attributes, JangoMail will call the web service for the last seven days worth of data. So if you specify a web service for the "open" event today, open data from the last seven days will immediately be posted to the web service.
3. The parameter values will be URL-encoded before they are passed to your web service via HTTP POST or GET.
4. You do not need to specify all parameters for a particular event. You only need to specify those parameters whose values you'd like your web service to receive.
5. Every time JangoMail makes a call to your web service, it is recorded in the Event API Log, which can be viewed under Reports --> Logs --> Transactional Event API. From here you can see a list of all successful and failed calls to your web service.
   

New API Method: AddTransactionalGroup

We just released a new API method for the JangoMail API which allows you to add a Transactional Group to your account:

*AddTransactionalGroup
  Adds a new Transactional Group to your account. Returns a string.

We also recently released 3 other transactional email API methods. These methods allow you to retrieve opens, clicks, unsubscribes, bounces, and complaint statistics for a single transactional email in your account.

Visit api.jangomail.com for a full list of our API methods.