Adding a user with Context.IO!

Context.IO is a powerful tool for building apps on top of email. One of the first things you’ll need to do is add your users to the API, so you can access their email data with your app. If, during the course of this guide, you feel stuck or have any questions please reach out to us! We’re here to make sure you love using our API! Shoot us an email at devangelists@context.io with any questions.

Setup your Context.IO account

Before we start we’re going to need to get all of our credentials setup and ready to go.

Add a client library to your app

Context.IO is a REST API and we can form our own requests without having to use one of the Context.IO libraries. If you’re using a language that we have a client library for, then you can use that to help you get started. There are setup guides in each library to help us get the basics going, once we’ve done that we’ll come back here to keep going!

We can access the current development version of the Context.IO libraries here:

Adding a user!

There are two main methods to add a user: using connect tokens or manually adding the account with either OAuth or login credentials. Using OAuth is only available for Google and Outlook.com accounts. In other cases, we’ll have to use login credentials. As the name suggests, adding a user manually means we’ll have the build the UX flow ourselves instead of having Context.IO do it for us.

  1. Add a user with connect tokens
  2. Add a user manually
    1. with credentials
    2. with Oauth

Add an email account with connect tokens

Using connect tokens will be the most familiar UX to our users. Connect tokens mirror the same “login with X” social media behavior our users are used to. Most importantly for us this saves time and code, we can spend more time creating our awesome email application!

Here is an outline of the process:

  • On our site a user clicks “Login with your email” and they are redirected to the Context.IO login screen.
    • We send a POST request with our callback_url as a parameter, to create the connect token
    • Context.IO responds with a redirect_url to the login screen
  • We send the user to the redirect_url which sends the user to the “Connect my mailbox” screen (presented/managed by Context.IO)
  • User gives us permission to access their account and is redirected back to the callback_url we specified in the POST request.

Lets setup a connect token flow using Context.IO

Lets add a 2.0 account. If we already have the info, we can pass in the email, first_name, and last_name of our user as optional parameters. This saves the user from having to fill out those forms. If we don’t know those yet, no worries, the user will be prompted to fill them out.

  1. require  ‘ContextIO’
  2. cio = ContextIO.new('your_api_key', 'your_api_secret')
  3. new_account = cio.request(
  4.   :post, 
  5.   "https://api.context.io/2.0/connect_tokens", 
  6.   {callback_url: ‘http://myapp.com/home’, email: ‘devangelists.contextio@earthlink.net’, first_name: ‘Tony’, last_name: ‘Blank’}
  7. ).body
  1. require  ‘ContextIO’

Here we are importing the lib

  1. cio = ContextIO.new('your_api_key', 'your_api_secret')

This instantiates the object you’ll use to make calls to the API.

  1. new_account = cio.request(
  2.   :post, 
  3.   "https://api.context.io/2.0/connect_tokens", 
  4.   {callback_url: ‘http://myapp.com/home’, email: ‘devangelists.contextio@earthlink.net’, first_name: ‘Tony’, last_name: ‘Blank’}
  5. ).body

This is what a request to the API looks like. Let’s break down the parameters we pass to the request function:

:post The http verb. This is typically get or post, depending on the call
“https://api.context.io/2.0/connect_tokens/” The resource URL
{callback_url: ‘http://myapp.com/home’, email: ‘devangelists.contextio@gmail.com, first_name: ‘Tony’, last_name: ‘Blank’} The only required param here is callback_url this tells Context.IO where to send the user after the login process is over
{
"success": true,
"token": "kay9ipcytfg3idtg",
"resource_url":  "https://api.context.io/2.0/connect_tokens/kay9ipcytfg3idtg", "browser_redirect_url": "https://connect.context.io/api/2.0/connect_tokens/kay9ipcytfg3idtg?email_address=devangelists.contextio%2540gmail.com&developer_key=54d6b5jbf2920cg660l8f206”
}

Now we will redirect users to the redirect_url, this will begin the login phase on the Context.IO side. If we want to see this flow we can make a token for our own account and paste the redirect_url into a browser.

After the user goes through our UX flow to gain permission to access their email account, they will be redirected back to the callback_url we specified. Now that we can access the user’s inbox we can make calls to access their email data to use in our app!

Manually add an account.

Currently only Gmail and Outlook.com support OAuth. It’s better to use OAuth because our connection won’t be lost if the user changes their password. With any other email provider,  we’ll need to get the user’s credentials.

We’re connecting to the email server in the same way a local email client does. We’ll need the same info that a desktop email client needs to access the email account to add that user to Context.IO.. We’re doing this so that we can have complete control over the UX flow and process where the user grants us access to their email.

Here are the three steps to manually setup this account:

  1. Create a Context.IO account for the email. This establishes the user in Context.IO.
  2. Fetch the server settings for the users email server. We’ll use the information return from this request to complete step C.
  3. Add the account using the information from step B. Once the account has been added we will be able to start making calls on the user’s email account.

Manually adding an account with user credentials.

A. Make a Context.IO account for the user

This does not grant access to this inbox it simply establishes an account for our user in Context.IO. This will create an account_id which identifies the user in Context.IO going forward.

  1. require 'ContextIO'
  2. cio = ContextIO.new('your_api_key', 'your_api_secret')
  3. accounts = cio.request(
  4.    :post,
  5.    "https://api.context.io/2.0/accounts/", 
  6.    {email: ‘devangelists.contextio@gmail.com, first_name: ‘Tony’, last_name: ‘Blank’}
  7. ).body

Let’s take a look at this line by line.

  1. require  ‘ContextIO’

The first thing you need to do is require the Context.IO ruby lib.

  1. cio = ContextIO.new('your_api_key', 'your_api_secret')

This instantiates the object you’ll use to make calls to the API.

  1. accounts = cio.request(
  2.   :post,
  3.   "https://api.context.io/2.0/accounts/",
  4.   {email: ‘devangelists.contextio@gmail.com, first_name: ‘Tony’, last_name: ‘Blank’}
  5. ).body

This is the API request. Let’s break down the parameters we pass to the request function:

:post The http verb. Typically post requests are used to add information, in this case it’s a user .
“https://api.context.io/2.0/accounts/” The resource URL, in this case it’s the accounts resource
{email: ‘devangelists.contextio@gmail.com, first_name: ‘Tony’, last_name: ‘Blank’} We’re passing the users email, first_name and last_name.
  1. {
  2.  "success": true,
  3.  "id": "5589c83ffcb8016d428b4580",
  4.  "resource_url": "https://api.context.io/2.0/accounts/5589c83ffcb8016d428b4580"
  5.  }

The response will come back as JSON. We’re going to include the account_id in all requests we make to fetch email data.

B. Fetch server settings from that account here

We’ll need more information about the account than the average user has off hand, (like the server and port number for example). We’ll make it easy for them by finding out info and adding it to the request.

  1. require  ‘ContextIO’
  2. cio = ContextIO.new('your_api_key', 'your_api_secret')
  3. accounts = cio.request(
  4.   :get, 
  5.   "https://api.context.io/2.0/discovery/",
  6.   {source_type: "IMAP", email: "devangelists.contextio@gmail.com"}
  7. ).body

Let’s take a look at this line by line.

  1. require  ‘ContextIO’

The first thing you need to do is require the Context.IO ruby lib.

  1. cio = ContextIO.new('your_api_key', 'your_api_secret')

This instantiates the object you’ll use to make calls to the API.

  1. accounts = cio.request(
  2.    :get, 
  3.    "https://api.context.io/2.0/discovery/",
  4.    {source_type: "IMAP", email: "devangelists.contextio@gmail.com"}
  5. ).body

This is the API request. Let’s break down the parameters we pass to the request function:

:get The http verb. This time we are requesting information so we’ll make a get request
“https://api.context.io/2.0/discovery” The resource URL, the discovery resource retrieves email server information
{source_type: “IMAP”, email: “devangelists.contextio@gmail.com”} We’re passing the source_type and email.
  1. {
  2.  "email": "devangelists.contextio@yahoo.com",
  3.  "found": true,
  4.  "type": "IMAP",
  5.  "imap": {
  6.  "server": "imap.mail.yahoo.com",
  7.  "username": "devangelists.contextio@yahoo.com",
  8.  "port": 993,
  9.  "use_ssl": true,   *(in our call we will use the integer1’ to represent true. ‘0’ would represent false)
  10.  "oauth": true
  11. },
  12.  "documentation": [ ]
  13.  }

When the response comes back we’re going to store a few fields in particular to make your next request. The above json is what the response will look like.

For some smaller email providers we might not get all of the information we need to move onto the next step. In that case we can either try to lookup the setting for that provider or ask the user for them.

C. Add the account using the information from steps A & B!

So far we’ve created an ID for this user in Context.IO, we’ve retrieved the email server settings for that account. Any info we don’t have yet, we’ll have to prompt the user for. Next, we  add the information we’ve already gathered along with the user’s password to create a fully authorized account for this user.

  1. require  ‘ContextIO’
  2. cio = ContextIO.new('your_api_key', 'your_api_secret')
  3. account = cio.request(
  4.   :post, 
  5.   "https://api.context.io/2.0/accounts/ID/sources”, 
  6.   {email:”devangelists.contextio@yahoo.com”,  server: imap.mail.yahoo.com, username:      “devangelists.contextio@yahoo.com”, use_ssl: 1, port: 993, type: ”, password: USERSPASSWORD}
  7. ).body

Let’s take a look at this line by line.

  1. require  ‘ContextIO’

The first thing you need to do is require the Context.IO ruby lib.

  1. cio = ContextIO.new('your_api_key', 'your_api_secret')

This instantiates the object you’ll use to make calls to the API.

  1. accounts = cio.request(
  2.    :post, 
  3.    "https://api.context.io/2.0/accounts/ID/sources/",
  4.    {email:”devangelists.contextio@yahoo.com”,  server: imap.mail.yahoo.com, username: “devangelists.contextio@yahoo.com”, use_ssl: 1, port: 993, type: ”, password: USERSPASSWORD"}
  5. ).body

This is the API request. Let’s break down the parameters we pass to the request function:

:post The http verb. This is a post because we are adding information to the resource
“https://api.context.io/2.0/accounts/ID/sources/” The resource URL, the sources resource holds user information
{email:”devangelists.contextio@yahoo.com”,  server: imap.mail.yahoo.com, username: “devangelists.contextio@yahoo.com”, use_ssl: 1, port: 993, type: ”, password: USERSPASSWORD”} We’re passing the parameters representing information we’ve gathered in the previous steps.

Once we’ve received our 201 created response we should be all set with this user! We can start making calls on their email account!

Manually adding an account with OAuth

Here are the 5 steps we’ll need to take to add a user manually with OAuth:

  1. Create a Google a client ID & client secret for our app so google recognizes us when we send our user for authentication.
  2. Add the user’s email, and name to Context.IO so we have an ID for that user in future calls.
  3. Fetch server setting from that accounts email server. We’ll need this information for add the account and it’s something the user generally doesn’t have on hand. This also helps confirm the type of email server, if a user has a company email and we can’t tell right away what inbox provider is powering the inbox on the backend.
  4. Acquire refresh and access tokens from the OAuth provider (in our case, it’s Google). This is a multi-step process often referred to as the “OAuth dance.”
  5. Connect the user’s email account to the Context.IO account using all the details we’ve obtained in the previous steps. Now that we have the user’s email account connected with OAuth our app can make calls on the user’s behalf.

1. Create a Client id & Client Secret from Google developers console.

Before we get started with our Context.IO code, it’s best to register our app with Google. We register the app so when the user is prompted to grant access, it will now show our app’s name and not Context.IO. Though it’s optional to have this screen branded as our app, users are more likely to grant access if we do this step, since they’ll recognize our app and probably won’t recognize Context.IO. Add them to our Context.IO app. Click “Create a project”

  1. From the project home screen:
    1. Click “Apis&auth” > “credentials” > “Create New Client ID”
    2. Choose “Web Application” under application type, then click “Configure consent screen”
    3. After you’ve entered your app name and hit save, click “Create Client ID” again.
  2. Once created, paste our Google client ID and secret to Context.IO, then click add.

2. Make a Context.IO account for the user

This does not grant access to this user’s email account it simply establishes an account for your user in Context.IO. This will create an account, with an account_id, which identifies the user in Context.IO.

  1. require 'ContextIO'
  2. cio = ContextIO.new('your_api_key', 'your_api_secret')
  3. accounts = cio.request(
  4.    :post,
  5.    "https://api.context.io/2.0/accounts/", 
  6.    {email: ‘devangelists.contextio@gmail.com, first_name: ‘Tony’, last_name: ‘Blank’}
  7. ).body

Let’s take a look at this line by line.

  1. require  ‘ContextIO’

The first thing you need to do is require the Context.IO ruby lib.

  1. cio = ContextIO.new('your_api_key', 'your_api_secret')

This instantiates the object you’ll use to make calls to the API.

  1. accounts = cio.request(
  2.    :post, 
  3.    "https://api.context.io/2.0/accounts/",
  4.    {email: ‘devangelists.contextio@gmail.com, first_name: ‘Tony’, last_name: ‘Blank’}
  5. ).body

This is the API request. Let’s break down the parameters we pass to the request function:

:post The http verb. Typically post requests are used to add information, in this case it’s a user .
“https://api.context.io/2.0/accounts/” The resource URL, in this case it’s the accounts resource
{email: ‘devangelists.contextio@gmail.com, first_name: ‘Tony’, last_name: ‘Blank’} We’re passing the users email, first_name and last_name.
  1. {
  2.  "success": true,
  3.  "id": "5589c83ffcb8016d428b4580",
  4.  "resource_url": "https://api.context.io/2.0/accounts/5589c83ffcb8016d428b4580"
  5.  }

The response will come back as JSON. We’re going to include the account_id in all requests we make to fetch email data.

3. Fetch server settings from that account here

We’ll need more information about the account than our average user has off hand, (like the server and port number for example). We’ll make it easy for them by finding out info and adding it to the request.

  1. require  ‘ContextIO’
  2. cio = ContextIO.new('your_api_key', 'your_api_secret')
  3. discovery = cio.request(
  4.   :get, 
  5.   "https://api.context.io/2.0/discovery”, 
  6.   {source_type: “IMAP”, email: “devangelists.contextio@yahoo.com”}
  7. ).body

Let’s take a look at this line by line.

  1. require  ‘ContextIO’

The first thing you need to do is require the Context.IO ruby lib.

  1. cio = ContextIO.new('your_api_key', 'your_api_secret')

This instantiates the object you’ll use to make calls to the API.

  1. discovery = cio.request(
  2.    :get, 
  3.    "https://api.context.io/2.0/discovery/",
  4.    {source_type: "IMAP", email: "devangelists.contextio@gmail.com"}
  5. ).body

This is the API request. Let’s break down the parameters we pass to the request function:

:get The http verb. This time we are requesting information so we’ll make a get request
“https://api.context.io/2.0/discovery” The resource URL, the discovery resource retrieves email server information
{source_type: “IMAP”, email: “devangelists.contextio@gmail.com”} We’re passing the source_type and email.
  1. {
  2.  "email": "devangelists.contextio@yahoo.com",
  3.  "found": true,
  4.  "type": "IMAP",
  5.  "imap": {
  6.  "server": "imap.mail.yahoo.com",
  7.  "username": "devangelists.contextio@yahoo.com",
  8.  "port": 993,
  9.  "use_ssl": true,   *(in our call we will use the integer1’ to represent true. ‘0’ would represent false)
  10.  "oauth": true
  11. },
  12.  "documentation": [ ]
  13.  }

When the response comes back we’re going to store a few fields in particular to make your next request. The above json is what the response will look like.

4. Request an OAuth token from Google for your user.

We’ve already registered our app with Google, we’ve created an account for the user with Context.IO and now we’re getting the user’s permission to let those two account communicate.

This will take a few steps:

  1. Request a temporary access token from Google.
  2. Obtain refresh token from the Google authentication server by exchanging our access token.
  3. Use the refresh token in your POST request to create the user’s account in Context.IO.
A. Obtain authorization token from Google authorization server

Follow the docs from Google to obtain your user’s Oauth token to get access to their email.

5. Add  the account using the information from step 2 & the OAuth token acquired in step 3!

Request:

  1. require 'ContextIO'
  2. cio = ContextIO.new('your_api_key', 'your_api_secret')
  3. account = cio.request(
  4.    :post, 
  5.    "https://api.context.io/2.0/accounts/ID/sources”, 
  6.    {email:”devangelists.contextio@gmail.com”,  server: imap.gmail.com, username: “devangelists.contextio@gmail.com”, use_ssl: 1, port: 993, type: ‘IMAP”, provider_refresh_token: “refresh token”, provider_consumer_key: “consumer key”}
  7. ).body

Let’s take a look at this line by line.

  1. require  ‘ContextIO’

The first thing you need to do is require the Context.IO ruby lib.

  1. cio = ContextIO.new('your_api_key', 'your_api_secret')

This instantiates the object you’ll use to make calls to the API.

  1. account = cio.request(
  2.    :post, 
  3.    "https://api.context.io/2.0/accounts/ID/sources”, 
  4.    {email:”devangelists.contextio@gmail.com”,  server: imap.gmail.com, username: “devangelists.contextio@gmail.com”, use_ssl: 1, port: 993, type: ‘IMAP”, provider_refresh_token: “refresh token”, provider_consumer_key: “consumer key”}
  5. ).body

This is the API request. Let’s break down the parameters we pass to the request function:

:post The http verb. Here we are making a post request with everything needed to create an account
“https://api.context.io/2.0/accounts/ID/sources” The resource URL, the sources resource holds user information
{email:”devangelists.contextio@gmail.com”,  server: imap.gmail.com, username: “devangelists.contextio@gmail.com”, use_ssl: 1, port: 993, type: ‘IMAP”, provider_refresh_token: “refresh token”, provider_consumer_key: “consumer key”} We’re passing all the required params to create an account

We’ve done it! We’ve create an account in Context.IO, The user has authorized Context.IO to make calls on their behalf, and we survived the OAuth dance relatively unscathed! Huzzah!

Hi! I’m Graham McBain, the New Evangelist!

What can I do to get you to use our API today

Hey, I like you!

I’m Graham McBain, the newest addition to the Context.IO Evangelism team. It’s only been a little over two weeks and I’m just about the happiest little chickadee there ever could be. Why? Because it’s serious fun helping engineers solve problems and I get to play an active role in this amazing community. Being an Evangelist affords me the opportunity to travel around the world, meeting great engineers along the way and seeing all the interesting things that can be done with email data. Dream job, right??

My first weekend on the road Tony and I went to LAHacks at UCLA. This event was really impressive, held in the stadium where the Basketball team plays and it was attended by over 1500 students. This was my first time giving the Context.IO pitch. I’m not one who gets nervous in front of people but it was still a daunting proposition. Luckily I passed my “rite of passage” with flying colors and the stress was balanced out with tons of fun.

Here’s a video of the paper airplane contest we held with our friends at Nest:

 

That next weekend I went to the inaugural HackCU in CU Boulder’s Idea Forge. Of the 100 students that showed up there were at least 20 solid hacks that would have given the LAHacks teams a run for their money.

HackCU ended on Sunday and Monday I was off to Austin to meet the rest of the Context.IO team. I worked from the beautiful downtown Austin office for a few days, ate some amazing BBQ, and then headed back to Denver on Wednesday. After finishing out the week at my desk I didn’t turn on my computer all weekend so I could process what had just happened.

I’m excited for what the future holds. Meeting more amazing engineers, showing people a product I believe in, and getting to share this time with some truly remarkable people. I look forward to meeting all of you and sharing my Context.IO story.

 

Graham R. McBain

Developer Evangelist, Context.IO

 

Email Data and Hardware? A Hack using Philips Hue Lights and Context.IO

Projects using hardware are rarely at the top of the list when developers are thinking about using email data and Context.IO. As more progress is made with smart gadgets, smart homes and the internet of things in general,  I think we’ll certainly see an uptick in hardware that integrates and takes advantage of email data.

Think about it – email remains relevant because it is so deeply integrated into people’s lives. That’s why we see so many developers working on altering and improving the email experience. Why not take advantage of that opportunity in the physical space?

A perfect example was the Context.IO prize winner from a recent hackathon we sponsored – Hack the Anvil at Purdue University in West Lafayette, Indiana. They used Philips Hue lights, natural language processing techniques and Context.IO to visualize the sentiment of a users incoming email messages. The Philips Hue lights will flash three times to alert you when you have a new email message. The color of the Hue lights will range from red to green, depending on the sentiment of the email you just received.

Pretty cool, right? I can imagine people in support who would love to use this app. Or maybe you are having a crummy day and only want to deal with the positive messages. Regardless of the use case, we loved to see such a fun email visualization tool! Read more about their project here.

If you’re interested in building your own hardware + email data project, here are a few more ideas we’ve come up with to get you started:

  • Give your smart device an email address and use Context.IO to process inbound emails. You now have a toaster that’s controlled via email.
  • Keep a Leap motion controller next to your keyboard so you can karate chop and archive emails you don’t need to read.
  • Put your users in a virtual email space and have them interact with email data in a 3d environment with an Oculus Rift.

Shoot us an email or tweet if you have other ideas or need help on a current project. Congrats again to team Red Lantern for building an awesome hack, the Anvil for hosting an amazing Purdue event and congrats in advance to whoever builds the email toaster. Mmm… toast…

 

Busy Weekend with PennApps and Microsoft Ventures

MLK weekend may have been a relaxing three day weekend for you, but our Developer Evangelist was on a non-stop trip to mentor student hackers and aspiring entrepreneurs.

Stop 1: PennApps Winter 2015!

This is our second time at PennApps and they really know how to step it up. The organizers did a fantastic job and we were among some awesome and innovative companies like ThalmicLabs,  Point.IO, Postmates, and Mashery. There were over 1,300 hackers this time from all around the world. Check out this clip to see what that looks like:

The goal is to solve real world problems and the Context.IO prize winner did just that. They were tired of showing up to class just to find out the professor had rescheduled or cancelled the class via email, so they used Context.IO and the Google calendar API to build Snowball. It’s a web app for students that works with a student email account and automatically updates your calendar and sends an alert to your Pebble watch when you receive an email about lecture or tutorial changes. What are they going to do next time class is cancelled? Our guess is a snowball fight. Congrats to Team Snowball on winning the Context.IO prize!

Context.IO prize winners

Tony with the Context.IO prize winners, Team Snowball!

Stop Two: Microsoft Ventures

We always love supporting local entrepreneurs, so we participated in an open house at our old stomping grounds – Capital Factory in Austin TX. Microsoft Ventures Accelerator shared information about their next Seattle class, followed by Q/A and a pitch session. We think our Evangelist did the best pitch, but we didn’t get any pictures so you’ll have to take our word for it.

And now, we rest! (for a day or two at least).

Defrag 2014

Context.IO was a proud sponsor of the Defrag Conference, which was held November, 18-19th in chilly Broomfield, Colorado.

Context.IO at Defrag

Tony Blank and Dan Corbin at Defrag 2014

Defrag focuses on internet-based tools that transform information into layers of knowledge. The conference motto is “accelerate the “aha” moment” and that’s exactly what it does. The two days were packed with presentations that explored the frontiers of technology in a variety of arenas like business, government, education, and healthcare. There were in depth and fascinating discussions on cloud computing, APIs, mobile technologies, big data, devops, and the Internet of things.

Those in attendance included developer evangelists, entrepreneurs, business strategists, venture capitalists, engineers, and analysts. It was diverse gathering of people passionate about all types of technology.

Crowd at Defrag

A packed crowd of attendees at Defrag.

The first day featured a number of API related talks that I found extremely interesting. These included:

Day two featured cool sessions on the cutting edge and frontiers of technology:

Overall, Defrag is truly one of the best conferences going and we hope to see you there next year!

The Amazing AirHelp App!

AirHelp has developed one of the most unique and intelligent uses of email that I’ve seen in a while. I love the power they give consumers and I think you will too. So…what exactly does AirHelp do?

AirHelp_logo_positive

Before we review their incredible solution, let’s describe the problem, because we’ve all been there. You’re at the airport when your flight is delayed, overbooked, or even cancelled. Most people don’t know that they are eligible for compensation when airlines cancel or delay flights. In fact, 26 million passengers are eligible for this type of compensation each year! Yet only two percent actually file a reimbursement claim. That means that airlines are sitting on about $16 billion of unclaimed money each year.

European and US airlines are often required to pay compensation when they screw up. The catch is you have to file a claim first. In Europe, you can claim up to $800 if your flight is delayed for more than three hours. In the US you can receive up to $1,300 if you’re involuntarily bumped from a flight that’s oversold. You have up to three years to file the claims so it’s worth seeing if you’re eligible. That’s where AirHelp comes in!

Air-passenger-rights2

AirHelp’s incredible app will scan your inbox for any flight itineraries. It then takes your flight information and cross-references it with their database of flights where passengers are eligible for compensation. If there’s match AirHelp will automatically file a claim on your behalf. The whole process takes about three minutes!

AirHelp_app_start screen

AirHelp averages $1050 or more in compensation per successful claim, which is way better than any voucher you’ll get from an airline. If a claim is successful then AirHelp will get 25% of what the airline pays you. If the claim is not valid then the claimant doesn’t owe a thing. You literally have nothing to lose so it’s worth signing up to see if you have money coming to you!

Inbox Love Conference

Context.IO and Return Path were proud to again sponsor the Inbox Love conference held on October 29th in Mountain View, CA. It was a packed house filled with designers, developers, product managers, startups, and angel investors.

Inbox Love Conference Kickoff

Josh Baer and Jared Goralnick kick off the Inbox Love Conference

The first session of the day was “It Ain’t Just IMAP: Building on Top of Email in 2014”, a panel discussion moderated by Jared Goralnick from AwayFind. The panel featured representatives from the Google, Microsoft, and Tony Blank, Developer Evangelist for Context.IO. It was an extremely informative session about on how to create amazing applications on top of email. As pioneers in the space, Context.IO is very excited to see both Google and Microsoft making it easier for developers to utilize the wealth of information in email.

It Ain’t Just IMAP: Building on Top of Email of 2014

Context.IO Developer Evangelist Tony Blank (far right) discusses the pros and cons of building on top of email.

There were also great sessions on email security and encryption, design strategies, how to make money in email, and an in-depth demo of Google Inbox app. It was fantastic to learn about incredible companies like Cirrus Insight which has built a number of powerful apps on top of email. The day wrapped up with a five minute lightning round of demos from FastMail, Front, Iterable, MixMax, Movable Ink, mxHero, TouchMail, Virtru, Vade Retro. Each company had their own unique and innovative features to make email better!

HackTX Winners: Best Context.IO Integration!

HackTX is an annual 24-hour university hackathon located deep in the heart of Texas. It has been student run on The University of Texas at Austin campus over the past two years, and Context.IO has been proud to sponsor the event each year.

HackTX

Teams work fast during HackTX

Almost 700 students on over 100 different teams competed for the top spots in the competition. A number of teams integrated Context.IO into their projects, and it wasn’t easy deciding which was most deserving of our prize for the best Context.IO hack.

The PushTV team

The PushTV team

Ultimately, we selected PushTV as the winners. Michael Li, Raymond Chee, Scott Zheng, Christopher Denny, and Gene Hsu were all part of the winning team. They integrated the API with DIRECTV’s web server so email messages could be displayed on the TV screen. Messages appeared on the top of the screen, much like a text message appears on your phone. Using a motion sensor, the user could either dismiss the message with the wave of a hand or read the whole message with a downward motion.

While the integration of email into such awesome technology was very cool, I was equally impressed with how they used the API to determine which emails to display and which to ignore. They used the contacts resource to tally which people you interact with the most via email and then parsed the subject lines of those emails to create a personalized list of keywords to look for when new messages arrive. In doing this, they created an algorithm that decides which messages are important enough to be displayed onscreen. Very clever!

The VR Dashboard team

The VR Dashboard team

While the PushTV team took home our prize, we want to give special recognition to the VR Dashboard team (Carlos A. Alaniz, German Zuniga, Dustin Torres, Jacob Figueroa, Casey Richardson). They used the Context.IO API to display live email data in a virtual reality headset. When wearing the headset, you got a 360-degree view of everything you needed to start the day – weather, important emails, top news items, etc. It was a great use of not only our API but also the virtual reality technology.

New Features!

exchange.png-550x0
Last month we announced you could test Exchange accounts on Lite. We started with basic functionality such as authentication, pulling folder and message lists, and fetching a raw message. Our Exchange development continues and we’re happy to announce support for even more endpoints.

We’ll keep you posted as we continue to roll out new Exchange resources. WebHooks for Exchange are coming very soon. We’re also working on the ability to pull folder meta data, message flags, and message meta data.

Your feedback guides our development plans. The other features listed below are all requests that were sent to support@context.io. We’d love to know which updates to our platform will make your application even better!

  • Exchange on Lite
    • Connect_Tokens – Create connect_tokens on Lite with Exchange accounts. Please note that to test the connect_tokens you’ll need to make the calls through the API since the creation of connect_tokens through the developer console has not yet been implemented.
    • Message Headers – The message headers endpoint on Lite supports Exchange messages. You can use this resource to pull the subject line, recipients copied on the message, mime-version, content-type, etc.
    • Message Body – Pull the message body from Exchange accounts in addition to the raw message body. Fetching a message body allows you to display it to the user, filter or group it based on content or sender, and hundreds of other use cases.
  • API Call Limit Increased – The API calls per minute limit on Lite has been increased from 120 to 240 per user. If you have a use case which requires more than 240 API calls per user per minute, please contact us at support@context.io and we can explore the option of a further increase.
  • Send Error Code For Empty Message Body – We return a more descriptive and instructive error code when a user oversubscribes the system. The new error code explains the issue is probably due to throttling and provides steps for you to resolve the problem. This should allow you to handle the error gracefully, correct the issue, and hopefully prevent it from occurring again.
  • BCC Related Headers for Lite WebHooks – If the headers exist in the Lite WebHook postbody, they are returned in the response. This will alleviate the need for a separate call to pull the BCC header data (original-to, x-original-to, envelope-to, x-rcptto).

If you haven’t already, we highly recommend you register for our status updates and bookmark our roadmap. Please email us at support@context.io if you have any questions whatsoever!

Join the Context.IO Team!

we-are-hiring

Want to work for one of the best companies in the country? Context.IO and Return Path are growing fast and looking for great people to join our team. We were just ranked the #2 Best Medium Workplace in America by Fortune Magazine. Not too shabby! If you’re a great engineer that cares about developers and helping them build amazing products, then we have an incredible job just waiting for you!

We’re looking to hire two Software Engineers for Context.IO. Are you curious with a drive to learn and ship code? Do you possess a versatile mindset with strong experience in at least one dynamic language? Then come work with us in the greatest city in the US, and possibly the world, Austin, Texas!

In addition to the software engineer positions we’re looking for an API Developer Evangelist to be located in Colorado, Austin, New York, or San Francisco. Your choice! This person will work directly with third party developers to help them solve real world business problems. We’re looking for someone skilled in web programming technologies, including JavaScript, REST and HTML5. Someone who’s great at writing compelling pieces and comfortable engaging all types of audiences, be it at hackathons, conferences or meetups.

Curious about working for Context.IO and Return Path? Contact us and we’ll be happy to answer any of your questions!